@mosa-ng/core 17.0.0

package/src/lib/services/core-logger.service.ts

@@ -0,0 +1,219 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ILogEvent } from '../models/logger/log-event.model';
+import { LogType } from '../models/logger/log-type.model';
+import { ILoggerConfig } from '../models/logger/logger-config.model';
+import { ILoggerDefaultConfig } from '../models/logger/logger-default-config.model';
+import { isNullOrUndefined } from '../utils/commons.util';
+
+@Injectable({
+    providedIn: 'root',
+})
+export class CoreLoggerService {
+
+    public defaultConfig: ILoggerDefaultConfig;
+
+    private readonly uiLogs$: BehaviorSubject<ILogEvent>;
+
+    /**
+     * Default constructor
+     */
+    constructor() {
+        this.uiLogs$ = new BehaviorSubject(null);
+    }
+
+    public subUiLogs(): Observable<ILogEvent> {
+        return this.uiLogs$.asObservable();
+    }
+
+    /**
+     * Gets the error message from any type of object
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public getErrorMsg(err: any): string {
+        let msg: string = 'Unknown Error';
+
+        if (!err) {
+            return msg;
+        }
+
+        if (err instanceof HttpErrorResponse) {
+            if (typeof err.error !== 'string') {
+                return `mosa.commons.errors.status[${ err.status }].message`;
+            }
+
+            return err.error;
+        }
+
+        if (typeof err === 'string') {
+            msg = err;
+        } else if (err.msg) {
+            msg = err.msg;
+        } else if (err.error?.msg) {
+            msg = err.error.msg;
+        } else if (err.error?.message) {
+            msg = err.error.message;
+        } else if (err.error?.errors && err.error?.errors[ 0 ]?.message) {
+            msg = err.error.errors[ 0 ].message;
+        } else if (err.message) {
+            msg = err.message;
+        } else if (err.Message) {
+            msg = err.Message;
+        }
+
+        if (typeof err.error === 'string') {
+            msg = err.error;
+        }
+
+        return msg;
+    }
+
+    /**
+     * Get the title to be shown in logger toast
+     * @param err
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    public getErrorTitle(err: any): string {
+        let title: string = 'mosa.commons.logs.error.label';
+        if (err?.label) {
+            title = err.label;
+        } else if (err?.title) {
+            title = err.title;
+        } else if (err?.error?.label) {
+            title = err.error.label;
+        } else if (err?.error?.title) {
+            title = err.error.title;
+        }
+        return title;
+    }
+
+    /**
+     * Logs an error to the user
+     * @param data
+     * @param showUser
+     * @param config
+     */
+    public logError(config: ILoggerConfig): void {
+        config = this.serializeConfig(config);
+        config.msg = this.getErrorMsg(config.msg);
+
+        if (!config.title) {
+            config.title = this.getErrorTitle(config.msg);
+        }
+
+        config.className = 'snackbar-error';
+
+        this.show(config, 'error');
+    }
+
+    /**
+     * Logs a success message to the user
+     * @param data
+     * @param config
+     */
+    public logSuccess(config: ILoggerConfig): void {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-success';
+
+        this.show(config, 'success');
+    }
+
+    /**
+     * Logs a warning to the user
+     * @param data
+     * @param showUser
+     * @param config
+     */
+    public logWarning(config: ILoggerConfig): void {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-warning';
+
+        this.show(config, 'warning');
+    }
+
+    /**
+     * Logs an info to the user
+     * @param data
+     * @param config
+     */
+    public logInfo(config: ILoggerConfig): void {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-info';
+
+        this.show(config, 'info');
+    }
+
+    /**
+     * Logs any kind of message to the user
+     * @param data
+     * @param config
+     */
+    public log(config: ILoggerConfig): void {
+        config = this.serializeConfig(config);
+        config.className = 'snackbar-default';
+
+        this.show(config, 'default');
+    }
+
+    /**
+     * Show the log
+     * @requires @mosa-ng/material
+     * @param data
+     * @param type
+     * @param config
+     */
+    public show(config: ILoggerConfig, type: LogType): void {
+        this.uiLogs$.next({ title: config.title, msg: config.msg, type, config });
+    }
+
+    /**
+     * Serializes empty values, so no error is being returned
+     * @param config
+     * @private
+     */
+    private serializeConfig(config: ILoggerConfig): ILoggerConfig {
+        // Check if user has default config
+        if (!this.defaultConfig) {
+            this.defaultConfig = {
+                debug: true,
+            };
+        }
+
+        if (!config) {
+            // Get user default config
+            config = {
+                showDismiss: this.defaultConfig.showDismiss,
+                closeOnClick: isNullOrUndefined(this.defaultConfig.closeOnClick) ? true : this.defaultConfig.closeOnClick,
+                className: this.defaultConfig.className,
+                duration: this.defaultConfig.duration || 4,
+            };
+        }
+
+        // Serialize configuration
+        config.duration = CoreLoggerService.getValue<number>(config.duration, this.defaultConfig.duration, 4);
+        config.className = CoreLoggerService.getValue<string>(config.className, this.defaultConfig.className, null);
+        config.showDismiss = CoreLoggerService.getValue<boolean>(config.showDismiss, this.defaultConfig.showDismiss, false);
+        config.closeOnClick = CoreLoggerService.getValue<boolean>(config.closeOnClick, this.defaultConfig.closeOnClick, true);
+
+        return config;
+    }
+
+    /**
+     * Gets a value which is not undefined or null
+     * @param val
+     * @param val1
+     * @param def
+     * @private
+     */
+    private static getValue<T>(val: T, val1: T, def: T): T {
+        if (isNullOrUndefined(val)) {
+            if (isNullOrUndefined(val1)) {
+                return def;
+            }
+            return val1;
+        }
+        return val;
+    }
+
+}

package/src/lib/services/guards/can-deactivate.guard.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { CanDeactivate } from '@angular/router';
+import { Observable } from 'rxjs';
+
+export interface CanComponentDeactivate {
+    canDeactivate: () => Observable<boolean> | Promise<boolean> | boolean;
+}
+
+@Injectable({
+    providedIn: 'root',
+})
+export class CanDeactivateGuard implements CanDeactivate<CanComponentDeactivate> {
+
+    public canDeactivate(component: CanComponentDeactivate): boolean {
+        return component.canDeactivate ? component.canDeactivate() as boolean : true;
+    }
+
+}

package/src/lib/services/mosa-socket.service.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+
+import { Observable, Observer, Subject } from 'rxjs';
+
+@Injectable({
+    providedIn: 'root',
+})
+export class MosaSocketService {
+
+    private subject: Subject<MessageEvent>;
+
+    constructor() {
+    }
+
+    public connect(url: string): Subject<MessageEvent> {
+        if (!this.subject) {
+            this.subject = this.create(url);
+        }
+        return this.subject;
+    }
+
+    public send(data: MessageEvent): void {
+        this.subject.next(data);
+    }
+
+    private create(url: string): Subject<MessageEvent> {
+        const ws = new WebSocket(url);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const observable = new Observable((obs: Observer<MessageEvent>): any => {
+            ws.onmessage = obs.next.bind(obs);
+            ws.onerror = obs.error.bind(obs);
+            ws.onclose = obs.complete.bind(obs);
+            return ws.close.bind(ws);
+        });
+        const observer = {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            next: (data: any): void => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify(data));
+                }
+            },
+        };
+        return Subject.create(observer, observable);
+    }
+
+}

package/src/lib/services/translation/assets-i18n-loader.service.ts

@@ -0,0 +1,67 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { firstValueFrom, Observable, of } from 'rxjs';
+import { catchError, share, tap } from 'rxjs/operators';
+import { IKeyMap } from '../../models/key-map.model';
+import { getRandomString } from '../../utils/commons.util';
+import { TranslateCollectorService } from './translate-collector.service';
+
+@Injectable({
+    providedIn: 'root',
+})
+export class AssetsI18nLoaderService {
+
+    protected priority: number = 0;
+    protected supportedLanguages: string[];
+
+    private subLanguages: Observable<{ languages: string[] }>;
+
+    constructor(
+        protected myHttpClient: HttpClient,
+        protected myTranslateCollectorService: TranslateCollectorService,
+    ) {
+    }
+
+    public init(path?: string, libName?: string, priority?: number): Promise<void> {
+        return new Promise(async (resolve: () => void): Promise<void> => {
+            if (this.supportedLanguages) {
+                for (let i: number = 0; i < this.supportedLanguages.length; i++) {
+                    await firstValueFrom(this.loadTranslations(this.supportedLanguages[ i ], path, libName, priority));
+                }
+                resolve();
+                return;
+            }
+
+            if (!this.subLanguages) {
+                this.subLanguages = this.myHttpClient.get<{ languages: string[] }>(`assets/i18n/supported-languages.json?v=${getRandomString()}`)
+                    .pipe(share());
+            }
+            this.subLanguages.subscribe(async (res: { languages: string[] }) => {
+                this.subLanguages = null;
+                this.supportedLanguages = res.languages;
+
+                for (let i: number = 0; i < this.supportedLanguages.length; i++) {
+                    await firstValueFrom(this.loadTranslations(this.supportedLanguages[ i ], path, libName, priority));
+                }
+                resolve();
+            }, () => {
+                this.subLanguages = null;
+                console.error('Missing file -> assets/i18n/supported-languages.json <-- FIX THIS!');
+                resolve();
+            });
+        });
+    }
+
+    protected loadTranslations(lang: string, path?: string, libName?: string, priority?: number): Observable<Record<string, string>> {
+        const filename: string = libName ? `${libName}-${lang}.json` : `${lang}.json`;
+        return this.myHttpClient.get<Record<string, string>>(`${(path || './assets/i18n/') + filename}?v=${getRandomString()}`)
+            .pipe(
+                tap((response: Record<string, string>) =>
+                    this.myTranslateCollectorService.addTranslations(response, lang, priority || this.priority)),
+                catchError(() => {
+                    console.error(`Missing file -> ${filename} <-- FIX THIS!`);
+                    return of(null);
+                }),
+            );
+    }
+}

package/src/lib/services/translation/custom-translate-loader.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { Observable, Observer } from 'rxjs';
+import { MOSA_FALLBACK_TRANSLATION, MOSA_MERGED_TRANSLATION } from '../../constants/local-storage.constant';
+import { IKeyMap } from '../../models/key-map.model';
+import { isNullOrEmpty, tryJsonParse } from '../../utils/commons.util';
+
+@Injectable({
+    providedIn: 'root',
+})
+export class CustomTranslateLoaderService {
+
+    public getTranslation(lang: string): Observable<IKeyMap<string>> {
+        return new Observable<IKeyMap<string>>((observer: Observer<IKeyMap<string>>) => {
+            const item: string = localStorage.getItem(MOSA_MERGED_TRANSLATION(lang));
+            const responseObj: IKeyMap<string> = tryJsonParse(item, () => this.loadFallbackLanguage());
+
+            observer.next(responseObj);
+            observer.complete();
+        });
+    }
+
+    private loadFallbackLanguage(): IKeyMap<string> {
+        const defaultTranslation: string = localStorage.getItem(MOSA_FALLBACK_TRANSLATION);
+        return isNullOrEmpty(defaultTranslation) ? {} : JSON.parse(defaultTranslation);
+    }
+
+}

package/src/lib/services/translation/translate-collector.service.ts

@@ -0,0 +1,60 @@
+import { Injectable } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { MOSA_MERGED_TRANSLATION } from '../../constants/local-storage.constant';
+import { IKeyMap } from '../../models/key-map.model';
+import { isNullOrUndefined } from '../../utils/commons.util';
+
+export interface ITranslationMap {
+    priority: number;
+    translation: IKeyMap<string>;
+}
+
+@Injectable({
+    providedIn: 'root',
+})
+export class TranslateCollectorService {
+
+    private translationMap: IKeyMap<ITranslationMap[]> = {};
+
+    constructor(private readonly myTranslateService: TranslateService) {
+    }
+
+    public addTranslations(translation: Record<string, string>, lang: string, priority: number): void {
+        if (isNullOrUndefined(this.translationMap[ lang ])) {
+            this.translationMap[ lang ] = [];
+        }
+
+        this.translationMap[ lang ].push({ priority, translation });
+        this.translationMap[ lang ].sort((a: ITranslationMap, b: ITranslationMap) => a.priority - b.priority);
+        const merged: IKeyMap<string> = JSON.parse(localStorage.getItem(MOSA_MERGED_TRANSLATION(lang))) || {};
+
+        for (const translationsData of this.translationMap[ lang ]) {
+            const translations: IKeyMap<string> = translationsData.translation;
+            if (translations != null) {
+                Object.keys(translations).forEach((key: string) => void (merged[ key ] = translations[ key ]));
+            }
+        }
+
+        let trans: boolean = true;
+        let count: number = 0;
+        while (trans) {
+            count++;
+            trans = false;
+            if (count >= 10) {
+                console.warn('Limit reached! Please check translation file! Last replaced values:');
+            }
+            Object.keys(merged).forEach((key: string) => {
+                if (merged[ key ].startsWith('@:')) {
+                    merged[ key ] = merged[ merged[ key ].substring(2, merged[ key ].length) ];
+                    trans = count < 10;
+                    if (count > 10) {
+                        console.warn(merged[ key ]);
+                    }
+                }
+            });
+        }
+        localStorage.setItem(MOSA_MERGED_TRANSLATION(lang), JSON.stringify(merged));
+        this.myTranslateService.reloadLang(lang);
+    }
+
+}

package/src/lib/utils/commons.util.ts

@@ -0,0 +1,100 @@
+import { ITransformMatrix } from '../models/transform-matrix.model';
+
+/**
+ * Checks if an object is null or undefined. Does not check for
+ * empty strings, or false booleans
+ * @param val
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isNullOrUndefined(val: any): boolean {
+    return val === null || val === undefined;
+}
+
+/**
+ * Checks if a string is null or empty
+ * @param str
+ */
+export function isNullOrEmpty(str: string): boolean {
+    return !str?.trim();
+}
+
+/**
+ * Checks if a string or number is zero or higher
+ * @param num
+ */
+export function isZeroOrHigher(num: number | string): boolean {
+    return num !== null && +num >= 0;
+}
+
+/**
+ * Checks if an object is a number
+ * @param num
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function isNumber(num: any): boolean {
+    return num !== null && !isNaN(+num);
+}
+
+/**
+ * Round to nearest number given
+ * @param value
+ * @param round
+ */
+export function roundNearest(value: number): number {
+    return Math.ceil(value / 5) * 5;
+}
+
+/**
+ * Merge a two dimensional array
+ * @param array
+ */
+export function mergeArray<T>(array: T[][]): T[] {
+    return array.reduce((flat: T[], toFlatten: T[] | T[][]): T[] =>
+        flat.concat(Array.isArray(toFlatten) ? mergeArray<T>(toFlatten as T[][]) : toFlatten), []);
+}
+
+/**
+ * Get CSS Transform matrix from an element
+ * @param element
+ */
+export function getTransformMatrix(element: HTMLElement): ITransformMatrix {
+    const values = element.style.transform.split(/\w+\(|\);?/);
+    const transform = values[ 1 ].split(/,\s?/g).map((numStr: string): number => parseInt(numStr, 10));
+
+    return {
+        x: transform[ 0 ],
+        y: transform[ 1 ],
+        z: transform[ 2 ],
+    };
+}
+
+/**
+ * Generates a random string with numbers and letters
+ * @param length
+ */
+export function getRandomString(length: number = 10): string {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result: string = '';
+    for (let i: number = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+/**
+ * Trys to convert a json string. If it fails it returns [null] or a given fallback of [T]
+ */
+export function tryJsonParse<T>(data: string, fallback?: () => T): T | null {
+    try {
+        if (!isNullOrEmpty(data)) {
+            return JSON.parse(data);
+        }
+    } catch (err: unknown) {
+        // Ignore - go on with fallback check
+    }
+
+    if (fallback) {
+        return fallback();
+    }
+    return null;
+}

package/src/lib/utils/dictionary.util.ts

@@ -0,0 +1,140 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { IDictionaryItem } from '../models/dictionary-item.model';
+import { IKeyMap } from '../models/key-map.model';
+
+export class Dictionary<Key, Value> {
+
+    private readonly dictionaryItems$: BehaviorSubject<IDictionaryItem<Key, Value>[]>;
+
+    /**
+     * Default constructor.
+     * @param data Requires an array of IDictionaryItem with a key and a value
+     */
+    constructor(...data: IDictionaryItem<Key, Value>[]) {
+        this.dictionaryItems$ = new BehaviorSubject<IDictionaryItem<Key, Value>[]>(data);
+    }
+
+    /**
+     * Observable to subscribe to dictionary changes
+     */
+    public valueChanges(): Observable<IDictionaryItem<Key, Value>[]> {
+        return this.dictionaryItems$.asObservable();
+    }
+
+    /**
+     * Observable to subscribe to dictionary as object changes
+     */
+    public objectArray(): Observable<IKeyMap<Value>> {
+        return this.dictionaryItems$.asObservable()
+            .pipe(
+                map((items: IDictionaryItem<Key, Value>[]): IKeyMap<Value> => this.toObject(items)),
+            );
+    }
+
+    /**
+     * Gets the items of the dictionary
+     * @returns dictionary items
+     */
+    public get items(): IDictionaryItem<Key, Value>[] {
+        return this.dictionaryItems$.value;
+    }
+
+    /**
+     * Gets a dictionary item by key
+     * @param key
+     * @returns single dictionary item
+     */
+    public get(key: Key): IDictionaryItem<Key, Value> {
+        return this.dictionaryItems$.value.find((item: IDictionaryItem<Key, Value>): boolean => item.key === key);
+    }
+
+    /**
+     * Checks if dictionary contains item
+     * @param key
+     */
+    public contains(key: Key): boolean {
+        return this.get(key) != null;
+    }
+
+    /**
+     * Adds a dictionary item
+     * @param key
+     * @param value
+     */
+    public add(key: Key, value: Value): void {
+        const dictionaryItems: IDictionaryItem<Key, Value>[] = [ ...this.dictionaryItems$.value ];
+        dictionaryItems.push({ key, value });
+        this.updateItems(dictionaryItems);
+    }
+
+    /**
+     * Updates a dictionary item
+     * @param data
+     * @param index
+     */
+    public update(data: IDictionaryItem<Key, Value>, index?: number): void {
+        const dictionaryItems: IDictionaryItem<Key, Value>[] = [ ...this.dictionaryItems$.value ];
+        if (!index) {
+            index = this.getIndex(data.key);
+        }
+
+        if (index !== -1) {
+            dictionaryItems[ index ] = data;
+        } else {
+            console.warn('Dictionary: Index not found');
+        }
+        this.updateItems(dictionaryItems);
+    }
+
+    /**
+     * Gets an index with a specific key
+     * @param key
+     */
+    public getIndex(key: Key): number {
+        return this.dictionaryItems$.value.findIndex((val: IDictionaryItem<Key, Value>): boolean => val.key === key);
+    }
+
+    /**
+     * Removes an item from the dictionary
+     * @param value
+     * @param index
+     */
+    public remove(value: Key, index?: number): void {
+        const dictionaryItems: IDictionaryItem<Key, Value>[] = [ ...this.dictionaryItems$.value ];
+        if (!index) {
+            index = this.getIndex(value);
+        }
+
+        if (index !== -1) {
+            dictionaryItems.splice(index, 1);
+        } else {
+            console.warn('Dictionary: Index not found');
+        }
+        this.updateItems(dictionaryItems);
+    }
+
+    /**
+     * Private function to cast array to an object
+     * @param items
+     * @private
+     */
+    private toObject(items: IDictionaryItem<Key, Value>[]): IKeyMap<Value> {
+        const obj: IKeyMap<Value> = {};
+        for (const item of items) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            obj[ item.key as any ] = item.value;
+        }
+        return obj;
+    }
+
+    /**
+     * Private function to update dictionary items
+     * @param items
+     * @private
+     */
+    private updateItems(items: IDictionaryItem<Key, Value>[]): void {
+        this.dictionaryItems$.next(items);
+    }
+
+}

package/src/lib/utils/item.util.ts

@@ -0,0 +1,4 @@
+export interface IItem {
+    key: number;
+    label: string;
+}

package/src/lib/utils/promise.util.ts

@@ -0,0 +1,3 @@
+export type PromiseResolve<T> = (value?: T | PromiseLike<T>) => void;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type PromiseReject = (reason?: any) => void;