@sumaris-net/ngx-components 3.0.0-rc1 → 4.0.0-rc10

package/esm2022/src/app/shared/inputs.mjs

@@ -0,0 +1,231 @@
+import { isFocusableElement } from './focusable';
+import { isNil, isNilOrBlank, isNotEmptyArray, isNotNil, toBoolean, toNumber } from './functions';
+export function selectInputContent(event) {
+    if (event.defaultPrevented)
+        return false;
+    const input = event.target;
+    if (!input)
+        return true;
+    // Nothing to select
+    if (isNilOrBlank(input.value))
+        return false;
+    if (typeof input.selectRange === 'function') {
+        try {
+            input.selectRange(input.value.length, 0);
+            return true;
+        }
+        catch (err) {
+            console.error('Could not select input content, using selectRange()', err);
+            return false;
+        }
+    }
+    if (input && typeof input.select === 'function') {
+        try {
+            input.select();
+            return true;
+        }
+        catch (err) {
+            console.error('Could not select input content, using select()', err);
+            return false;
+        }
+    }
+    return true;
+}
+export function selectInputRange(input, startIndex, endIndex) {
+    if (input && typeof input.setSelectionRange === 'function') {
+        // No content
+        if (isNilOrBlank(input.value))
+            return false;
+        try {
+            input.setSelectionRange(startIndex, isNotNil(endIndex) ? endIndex : startIndex);
+        }
+        catch (err) {
+            console.error('Could not select input range', err);
+            return false;
+        }
+    }
+    return true;
+}
+export function getCaretPosition(input) {
+    if (input && input.selectionStart != null) {
+        return input.selectionDirection ?
+            (input.selectionDirection === 'backward' ? input.selectionStart : input.selectionEnd) : input.selectionStart;
+    }
+    return -1;
+}
+export function moveInputCaretToSeparator(event, separator, forward) {
+    if (event.defaultPrevented || !separator)
+        return false;
+    const input = event.target;
+    if (!input)
+        return true;
+    const caretPosition = getCaretPosition(input);
+    // DEBUG
+    //console.debug('caretPosition=', caretPosition);
+    if (caretPosition === -1)
+        return true; // Caret pos not found: skip
+    // Get input value
+    const value = input.value;
+    // No content: skip
+    if (isNilOrBlank(value))
+        return false;
+    try {
+        if (value && caretPosition <= value.length) {
+            // DEBUG
+            //console.debug("Input text value: ", value);
+            //console.debug("Cursor at: ", caretPosition);
+            //console.debug("Text after cursor: ", value.substr(caretPosition));
+            //console.debug("Next separator at: ", value.indexOf(separator, caretPosition));
+            forward = forward !== false;
+            const separatorIndex = (forward ? value.indexOf(separator, caretPosition) : value.lastIndexOf(separator, caretPosition));
+            if (separatorIndex !== -1 && ((forward && separatorIndex + 1 < value.length)
+                || (!forward && separatorIndex > 0))) {
+                if (input.setSelectionRange) {
+                    // Move after the next separator
+                    if (selectInputRange(input, separatorIndex + (forward ? 1 : -1))) {
+                        // Stop the keyboard event
+                        event.preventDefault();
+                        event.stopPropagation();
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error('Could not move caret to next separator', err);
+        return false;
+    }
+    return true;
+}
+export function filterNumberInput(event, allowDecimals, decimalSeparator) {
+    //input number entered or one of the 4 direction up, down, left and right
+    if ((event.which >= 48 && event.which <= 57) || (event.which >= 37 && event.which <= 40)) {
+        //console.debug('input number entered :' + event.which + ' ' + event.keyCode + ' ' + event.charCode);
+        // OK
+    }
+    // Decimal separator
+    else if (allowDecimals && ((!decimalSeparator && (event.key === '.' || event.key === ','))
+        || (decimalSeparator && event.key === decimalSeparator))) {
+        //console.debug('input decimal separator entered :' + event.code);
+        // OK
+    }
+    else {
+        //input command entered of delete, backspace or one of the 4 direction up, down, left and right, or negative sign
+        if ((event.keyCode >= 37 && event.keyCode <= 40) || event.keyCode == 46 || event.which == 8 || event.keyCode == 9 || event.keyCode == 45) {
+            //console.debug('input command entered :' + event.which + ' ' + event.keyCode + ' ' + event.charCode);
+            // OK
+        }
+        // Cancel other keyboard events
+        else {
+            //console.debug('input not number entered :' + event.which + ' ' + event.keyCode + ' ' + event.charCode + ' ' + event.code );
+            event.preventDefault();
+        }
+    }
+}
+export function focusInput(element) {
+    const inputElement = asInputElement(element);
+    if (inputElement)
+        inputElement.focus();
+    else {
+        console.warn('Trying to focus on this element:', element);
+    }
+}
+export function setTabIndex(element, tabIndex) {
+    if (isInputElement(element)) {
+        element.tabindex = tabIndex;
+    }
+    else if (element && isInputElement(element.nativeElement)) {
+        element.nativeElement.tabIndex = tabIndex;
+    }
+    else {
+        console.warn('Trying to change tabindex on this element:', element);
+    }
+}
+export function isInputElement(object) {
+    return isFocusableElement(object)
+        && ('value' in object
+            // has value is not always set (neither tabindex) check on 2 properties with a logical OR
+            || ('tabindex' in object || 'tabIndex' in object));
+}
+export function asInputElement(object) {
+    if (object) {
+        if (isInputElement(object))
+            return object;
+        if (object.nativeElement && isInputElement(object.nativeElement))
+            return object.nativeElement;
+    }
+    return undefined;
+}
+export function tabindexComparator(a, b) {
+    const valueA = a.tabindex || a.tabIndex;
+    const valueB = b.tabindex || b.tabIndex;
+    return valueA === valueB ? 0 : (valueA > valueB ? 1 : -1);
+}
+export function canHaveFocus(input, opts) {
+    if (!input)
+        return false;
+    // Exclude disabled element
+    return !toBoolean(input.disabled, false)
+        // Exclude hidden element
+        && !toBoolean(input.hidden, false)
+        // Exclude minTabIndex < element.tabIndex
+        && (isNil(opts.minTabindex) || toNumber(input.tabIndex, input.tabindex) > opts.minTabindex)
+        // Exclude maxTabIndex > element.tabIndex
+        && (isNil(opts.maxTabindex) || toNumber(input.tabIndex, input.tabindex) < opts.maxTabindex)
+        // Exclude nil input value
+        && (!opts.excludeEmptyInput || isNilOrBlank(input.value));
+}
+export function getFocusableInputElements(elements, opts) {
+    opts = { sortByTabIndex: false, excludeEmptyInput: false, ...opts };
+    // Focus to first input
+    const filteredElements = elements
+        // Transform to input
+        .map(asInputElement)
+        .filter(input => {
+        const included = canHaveFocus(input, opts);
+        // DEBUG
+        if (input && opts.debug)
+            console.debug(`[inputs] Focusable input {canFocus: ${included}, tabIndex: ${input.tabIndex || input.tabindex}}`, input);
+        return included;
+    });
+    // Sort by tabIndex
+    if (opts.sortByTabIndex) {
+        return filteredElements.sort(tabindexComparator);
+    }
+    return filteredElements;
+}
+export function focusNextInput(event, elements, opts) {
+    // Cancelling event (e.g. when emitted by (keydown.tab) )
+    if (event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    // Get current index
+    const minTabindex = event && isInputElement(event.target) ? (event.target.tabIndex || event.target.tabindex) : undefined;
+    // Get focusable input elements
+    const focusableInputs = getFocusableInputElements(elements, { minTabindex, ...opts });
+    if (isNotEmptyArray(focusableInputs)) {
+        // Focus on first inputs
+        focusableInputs[0].focus();
+        return true;
+    }
+    return false;
+}
+export function focusPreviousInput(event, elements, opts) {
+    // Cancelling event (e.g. when emitted by (keydown.tab) )
+    if (event) {
+        event.preventDefault();
+        event.stopPropagation();
+    }
+    // Get current index
+    const maxTabindex = event && isInputElement(event.target) ? (event.target.tabIndex || event.target.tabindex) : undefined;
+    // Get focusable input elements
+    const focusableInputs = getFocusableInputElements(elements, { maxTabindex, ...opts });
+    if (isNotEmptyArray(focusableInputs)) {
+        // Focus on last inputs
+        focusableInputs[focusableInputs.length - 1].focus();
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"inputs.js","sourceRoot":"","sources":["../../../../../src/app/shared/inputs.ts"],"names":[],"mappings":"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","sourcesContent":["import {ElementRef, QueryList} from '@angular/core';\nimport {FocusableElement, isFocusableElement} from './focusable';\nimport {isNil, isNilOrBlank, isNotEmptyArray, isNotNil, toBoolean, toNumber} from './functions';\n\n\n\n\nexport function selectInputContent(event: Event) {\n  if (event.defaultPrevented) return false;\n  const input = (event.target as any);\n  if (!input) return true;\n\n  // Nothing to select\n  if (isNilOrBlank(input.value)) return false;\n\n  if (typeof input.selectRange === 'function') {\n    try {\n      input.selectRange(input.value.length, 0);\n      return true;\n    } catch (err) {\n      console.error('Could not select input content, using selectRange()', err);\n      return false;\n    }\n  }\n\n  if (input && typeof input.select === 'function') {\n    try {\n      input.select();\n      return true;\n    } catch (err) {\n      console.error('Could not select input content, using select()', err);\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function selectInputRange(input: any, startIndex: number, endIndex?: number) {\n  if (input && typeof input.setSelectionRange === 'function') {\n\n    // No content\n    if (isNilOrBlank(input.value)) return false;\n\n    try {\n      input.setSelectionRange(startIndex, isNotNil(endIndex) ? endIndex : startIndex);\n    } catch (err) {\n      console.error('Could not select input range', err);\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function getCaretPosition(input: any): number {\n  if (input && input.selectionStart != null) {\n    return input.selectionDirection ?\n      (input.selectionDirection === 'backward' ? input.selectionStart : input.selectionEnd) : input.selectionStart;\n  }\n  return -1;\n}\n\nexport function moveInputCaretToSeparator(event: KeyboardEvent, separator: string, forward?: boolean) {\n  if (event.defaultPrevented || !separator) return false;\n  const input = (event.target as any);\n  if (!input) return true;\n\n  const caretPosition = getCaretPosition(input);\n\n  // DEBUG\n  //console.debug('caretPosition=', caretPosition);\n\n  if (caretPosition === -1) return true; // Caret pos not found: skip\n\n  // Get input value\n  const value = input.value as string;\n\n  // No content: skip\n  if (isNilOrBlank(value)) return false;\n\n  try {\n\n\n    if (value && caretPosition <= value.length) {\n      // DEBUG\n      //console.debug(\"Input text value: \", value);\n      //console.debug(\"Cursor at: \", caretPosition);\n      //console.debug(\"Text after cursor: \", value.substr(caretPosition));\n      //console.debug(\"Next separator at: \", value.indexOf(separator, caretPosition));\n\n      forward = forward !== false;\n\n      const separatorIndex = (forward ? value.indexOf(separator, caretPosition) : value.lastIndexOf(separator, caretPosition));\n      if (separatorIndex !== -1 && ((forward && separatorIndex + 1 < value.length)\n        || (!forward && separatorIndex > 0))) {\n        if (input.setSelectionRange) {\n          // Move after the next separator\n          if (selectInputRange(input, separatorIndex + (forward ? 1 : -1))) {\n            // Stop the keyboard event\n            event.preventDefault();\n            event.stopPropagation();\n          }\n        }\n      }\n    }\n  } catch (err) {\n    console.error('Could not move caret to next separator', err);\n    return false;\n  }\n  return true;\n}\n\nexport function filterNumberInput(event: KeyboardEvent, allowDecimals: boolean, decimalSeparator?: string) {\n  //input number entered or one of the 4 direction up, down, left and right\n  if ((event.which >= 48 && event.which <= 57) || (event.which >= 37 && event.which <= 40)) {\n    //console.debug('input number entered :' + event.which + ' ' + event.keyCode + ' ' + event.charCode);\n    // OK\n  }\n  // Decimal separator\n  else if (allowDecimals && ((!decimalSeparator && (event.key === '.' || event.key === ','))\n    || (decimalSeparator && event.key === decimalSeparator))) {\n    //console.debug('input decimal separator entered :' + event.code);\n    // OK\n  } else {\n    //input command entered of delete, backspace or one of the 4 direction up, down, left and right, or negative sign\n    if ((event.keyCode >= 37 && event.keyCode <= 40) || event.keyCode == 46 || event.which == 8 || event.keyCode == 9 || event.keyCode == 45) {\n      //console.debug('input command entered :' + event.which + ' ' + event.keyCode + ' ' + event.charCode);\n      // OK\n    }\n    // Cancel other keyboard events\n    else {\n      //console.debug('input not number entered :' + event.which + ' ' + event.keyCode + ' ' + event.charCode + ' ' + event.code );\n      event.preventDefault();\n    }\n  }\n}\n\nexport function focusInput(element: ElementRef) {\n  const inputElement = asInputElement(element);\n  if (inputElement)\n    inputElement.focus();\n  else {\n    console.warn('Trying to focus on this element:', element);\n  }\n}\n\nexport function setTabIndex(element: ElementRef, tabIndex: number) {\n  if(isInputElement(element)) {\n    element.tabindex = tabIndex;\n  }\n  else if (element && isInputElement(element.nativeElement)) {\n    element.nativeElement.tabIndex = tabIndex;\n  }\n  else {\n    console.warn('Trying to change tabindex on this element:', element);\n  }\n}\n\nexport interface InputElement extends FocusableElement {\n  tabindex?: number;\n  tabIndex?: number;\n  hidden?: boolean;\n  disabled?: boolean;\n  value: any;\n}\nexport function isInputElement(object: any): object is InputElement {\n  return isFocusableElement(object)\n    && ('value' in object\n      // has value is not always set (neither tabindex) check on 2 properties with a logical OR\n      || ('tabindex' in object || 'tabIndex' in object));\n}\n\nexport function asInputElement(object: ElementRef): InputElement|undefined {\n  if (object) {\n    if (isInputElement(object)) return object;\n    if (object.nativeElement && isInputElement(object.nativeElement)) return object.nativeElement;\n  }\n  return undefined;\n}\n\nexport function tabindexComparator(a: InputElement, b: InputElement) {\n  const valueA = a.tabindex || a.tabIndex;\n  const valueB = b.tabindex || b.tabIndex;\n  return valueA === valueB ? 0 : (valueA > valueB ? 1 : -1);\n}\n\nexport interface CanGainFocusOptions {\n  minTabindex?: number;\n  maxTabindex?: number;\n  excludeEmptyInput?: boolean;\n}\n\nexport interface GetFocusableInputOptions extends CanGainFocusOptions {\n  sortByTabIndex?: boolean;\n  debug?: boolean;\n}\n\nexport function canHaveFocus(input: InputElement, opts?: CanGainFocusOptions): boolean {\n  if (!input) return false;\n  // Exclude disabled element\n  return !toBoolean(input.disabled, false)\n    // Exclude hidden element\n    && !toBoolean(input.hidden, false)\n    // Exclude minTabIndex < element.tabIndex\n    && (isNil(opts.minTabindex) || toNumber(input.tabIndex, input.tabindex) > opts.minTabindex)\n    // Exclude maxTabIndex > element.tabIndex\n    && (isNil(opts.maxTabindex) || toNumber(input.tabIndex, input.tabindex) < opts.maxTabindex)\n    // Exclude nil input value\n    && (!opts.excludeEmptyInput || isNilOrBlank(input.value));\n}\n\nexport function getFocusableInputElements(elements: QueryList<ElementRef>, opts?: GetFocusableInputOptions): InputElement[] {\n  opts = {sortByTabIndex: false, excludeEmptyInput: false, ...opts};\n\n  // Focus to first input\n  const filteredElements: InputElement[] = elements\n\n    // Transform to input\n    .map(asInputElement)\n\n    .filter(input => {\n      const included = canHaveFocus(input, opts);\n      // DEBUG\n      if (input && opts.debug) console.debug(`[inputs] Focusable input {canFocus: ${included}, tabIndex: ${input.tabIndex||input.tabindex}}`, input);\n      return included;\n    });\n\n  // Sort by tabIndex\n  if (opts.sortByTabIndex) {\n    return filteredElements.sort(tabindexComparator);\n  }\n\n  return filteredElements;\n\n}\n\n\nexport function focusNextInput(event: Event|undefined, elements: QueryList<ElementRef>, opts?: GetFocusableInputOptions): boolean {\n\n  // Cancelling event (e.g. when emitted by (keydown.tab) )\n  if (event) {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  // Get current index\n  const minTabindex = event && isInputElement(event.target) ? (event.target.tabIndex || event.target.tabindex) : undefined;\n\n  // Get focusable input elements\n  const focusableInputs: InputElement[] = getFocusableInputElements(elements, {minTabindex, ...opts});\n\n  if (isNotEmptyArray(focusableInputs)) {\n    // Focus on first inputs\n    focusableInputs[0].focus();\n    return true;\n  }\n\n  return false;\n}\n\nexport function focusPreviousInput(event: Event|undefined, elements: QueryList<ElementRef>, opts?: GetFocusableInputOptions): boolean {\n\n  // Cancelling event (e.g. when emitted by (keydown.tab) )\n  if (event) {\n    event.preventDefault();\n    event.stopPropagation();\n  }\n\n  // Get current index\n  const maxTabindex = event && isInputElement(event.target) ? (event.target.tabIndex || event.target.tabindex) : undefined;\n\n  // Get focusable input elements\n  const focusableInputs: InputElement[] = getFocusableInputElements(elements, {maxTabindex, ...opts});\n\n  if (isNotEmptyArray(focusableInputs)) {\n    // Focus on last inputs\n    focusableInputs[focusableInputs.length -1].focus();\n    return true;\n  }\n\n  return false;\n}\n\n"]}

package/esm2022/src/app/shared/interceptors/progess.interceptor.mjs

@@ -0,0 +1,28 @@
+import { __decorate, __param } from "tslib";
+import { catchError, tap } from 'rxjs/operators';
+import { HttpResponse } from '@angular/common/http';
+import { APP_PROGRESS_BAR_SERVICE } from '../services/progress-bar.service';
+import { Inject } from '@angular/core';
+let ProgressInterceptor = class ProgressInterceptor {
+    progressBarService;
+    constructor(progressBarService) {
+        this.progressBarService = progressBarService;
+    }
+    intercept(req, next) {
+        this.progressBarService.increase();
+        return next.handle(req)
+            .pipe(tap(event => {
+            if (event instanceof HttpResponse) {
+                this.progressBarService.decrease();
+            }
+        }), catchError((err, event) => {
+            this.progressBarService.decrease();
+            throw err;
+        }));
+    }
+};
+ProgressInterceptor = __decorate([
+    __param(0, Inject(APP_PROGRESS_BAR_SERVICE))
+], ProgressInterceptor);
+export { ProgressInterceptor };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/logging/logging-service.class.mjs

@@ -0,0 +1,128 @@
+import { LogUtils } from './logger.model';
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { DateUtils } from '../dates';
+import { APP_STORAGE } from '../storage/storage.utils';
+import { ENVIRONMENT } from '../../../environments/environment.class';
+import { debounceTime } from 'rxjs/operators';
+import { isEmptyArray, isNotEmptyArray } from '../functions';
+import { LogLevel } from './log-level.model';
+import { StartableService } from '../services/startable-service.class';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../environments/environment.class";
+export class Logger {
+    _name;
+    _appender;
+    constructor(_name, _appender) {
+        this._name = _name;
+        this._appender = _appender;
+    }
+    trace(methodName, ...params) {
+        this._appender.append(this._name, LogLevel.TRACE, this.toString(methodName, ...params));
+    }
+    debug(methodName, ...params) {
+        this._appender.append(this._name, LogLevel.DEBUG, this.toString(methodName, ...params));
+    }
+    info(methodName, ...params) {
+        this._appender.append(this._name, LogLevel.INFO, this.toString(methodName, ...params));
+    }
+    warn(methodName, ...params) {
+        this._appender.append(this._name, LogLevel.WARN, this.toString(methodName, ...params));
+    }
+    error(methodName, ...params) {
+        this._appender.append(this._name, LogLevel.ERROR, this.toString(methodName, ...params));
+    }
+    fatal(methodName, ...params) {
+        this._appender.append(this._name, LogLevel.FATAL, this.toString(methodName, ...params));
+    }
+    toString(methodName, ...params) {
+        return `[${methodName}] ` + (params || []).map(p => {
+            if (typeof p === 'string')
+                return p;
+            if (typeof p === 'number')
+                return '' + p;
+            return JSON.stringify(p);
+        }).join(' ');
+    }
+}
+export const APP_LOGGING_SERVICE = new InjectionToken('LoggingService');
+export class LoggingService extends StartableService {
+    storage;
+    environment;
+    _dataSubject = new BehaviorSubject([]);
+    _debounceTimeMs;
+    _storageKey;
+    _maxMessages;
+    _saving = false;
+    constructor(storage, environment) {
+        super(storage);
+        this.storage = storage;
+        this.environment = environment;
+        this.configure(environment.logging);
+    }
+    async configure(config) {
+        await this.restart(config);
+    }
+    async ngOnStart(opts) {
+        this._debounceTimeMs = opts?.localStorageAppender?.debounceTimeMs || 1000 /* = 1s */;
+        this._maxMessages = opts?.localStorageAppender?.maxMessages || 250;
+        this._storageKey = opts?.localStorageAppender?.localStorageKey || 'log';
+        console.info(`[logging] Configuring logging... {localStorageKey: '${this._storageKey}', maxMessages: ${this._maxMessages}, savePeriodMs: ${this._debounceTimeMs}}`);
+        // Save timer
+        this.registerSubscription(this._dataSubject
+            // Avoid to many call
+            .pipe(debounceTime(this._debounceTimeMs))
+            .subscribe(() => this.storeLocally()));
+    }
+    getLogger(loggerName) {
+        return new Logger(loggerName, this);
+    }
+    append(loggerName, level, message) {
+        this._dataSubject.next([
+            ...this._dataSubject.value,
+            { loggerName, level, message, date: DateUtils.moment() }
+        ]);
+    }
+    async storeLocally() {
+        if (this._saving)
+            return;
+        this._saving = true;
+        try {
+            const newMessages = (this._dataSubject.value || []).map(LogUtils.asObject);
+            if (isEmptyArray(newMessages))
+                return; // Skip if no data
+            this._dataSubject.next([]); // Reset log
+            const oldValue = await this.storage.get(this._storageKey);
+            const oldMessages = (typeof oldValue === 'string') ? JSON.parse(oldValue) : (oldValue || []);
+            let lastMessages = [
+                ...(oldMessages || []),
+                ...newMessages
+            ];
+            if (lastMessages.length > this._maxMessages) {
+                lastMessages = lastMessages.slice(lastMessages.length - this._maxMessages);
+            }
+            if (isNotEmptyArray(lastMessages)) {
+                console.info(`[logging] Saving ${newMessages.length} messages to storage...`);
+                await this.storage.set(this._storageKey, lastMessages);
+            }
+        }
+        catch (err) {
+            console.error(err);
+        }
+        finally {
+            this._saving = false;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: LoggingService, deps: [{ token: APP_STORAGE }, { token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: LoggingService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: LoggingService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_STORAGE]
+                }] }, { type: i1.Environment, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logging-service.class.js","sourceRoot":"","sources":["../../../../../../src/app/shared/logging/logging-service.class.ts"],"names":[],"mappings":"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","sourcesContent":["import {ILogger, ILoggingAppender, ILoggingService, Log, LogUtils} from './logger.model';\nimport {Inject, Injectable, InjectionToken} from '@angular/core';\nimport {BehaviorSubject} from 'rxjs';\nimport {DateUtils} from '../dates';\nimport {APP_STORAGE, IStorage} from '../storage/storage.utils';\nimport {Environment, ENVIRONMENT} from '../../../environments/environment.class';\nimport {debounceTime} from 'rxjs/operators';\nimport {isEmptyArray, isNotEmptyArray} from '../functions';\nimport {LoggingServiceConfig} from './logging-service.config';\nimport {LogLevel} from './log-level.model';\nimport {StartableService} from '../services/startable-service.class';\n\n\nexport class Logger implements ILogger {\n  constructor(private _name: string,\n              private _appender: ILoggingAppender) {\n  }\n\n  trace(methodName: string, ...params: any[]): void {\n    this._appender.append(this._name, LogLevel.TRACE, this.toString(methodName, ...params));\n  }\n\n  debug(methodName: string, ...params: any[]): void {\n    this._appender.append(this._name, LogLevel.DEBUG, this.toString(methodName, ...params));\n  }\n\n  info(methodName: string, ...params: any[]): void {\n    this._appender.append(this._name, LogLevel.INFO, this.toString(methodName, ...params));\n  }\n\n  warn(methodName: string, ...params: any[]): void {\n    this._appender.append(this._name, LogLevel.WARN, this.toString(methodName, ...params));\n  }\n\n  error(methodName: string, ...params: any[]) {\n    this._appender.append(this._name, LogLevel.ERROR, this.toString(methodName, ...params));\n  }\n\n  fatal(methodName: string, ...params: any[]) {\n    this._appender.append(this._name, LogLevel.FATAL, this.toString(methodName, ...params));\n  }\n\n  private toString(methodName, ...params: any[]) {\n    return `[${methodName}] ` + (params || []).map(p => {\n      if (typeof p === 'string') return p;\n      if (typeof p === 'number') return '' + p;\n      return JSON.stringify(p);\n    }).join(' ');\n  }\n}\n\nexport const APP_LOGGING_SERVICE = new InjectionToken<ILoggingService>('LoggingService');\n\n@Injectable()\nexport class LoggingService extends StartableService<void> implements ILoggingService, ILoggingAppender {\n\n  _dataSubject = new BehaviorSubject<Log[]>([]);\n  _debounceTimeMs: number;\n  _storageKey: string;\n  _maxMessages: number;\n  _saving = false;\n\n  constructor(@Inject(APP_STORAGE) private storage: IStorage,\n              @Inject(ENVIRONMENT) protected environment: Environment\n  ) {\n    super(storage);\n    this.configure(environment.logging);\n  }\n\n  async configure(config: LoggingServiceConfig) {\n    await this.restart(config);\n  }\n\n  protected async ngOnStart(opts?: LoggingServiceConfig): Promise<void> {\n    this._debounceTimeMs = opts?.localStorageAppender?.debounceTimeMs || 1000 /* = 1s */;\n    this._maxMessages = opts?.localStorageAppender?.maxMessages || 250;\n    this._storageKey = opts?.localStorageAppender?.localStorageKey || 'log';\n\n    console.info(`[logging] Configuring logging... {localStorageKey: '${this._storageKey}', maxMessages: ${this._maxMessages}, savePeriodMs: ${this._debounceTimeMs}}`);\n\n    // Save timer\n    this.registerSubscription(\n      this._dataSubject\n      // Avoid to many call\n      .pipe(\n        debounceTime(this._debounceTimeMs)\n      )\n      .subscribe(() => this.storeLocally())\n    );\n  }\n\n  getLogger(loggerName: string): ILogger {\n    return new Logger(loggerName, this);\n  }\n\n  append(loggerName: string, level: LogLevel, message: string) {\n    this._dataSubject.next([\n      ...this._dataSubject.value,\n      <Log>{loggerName, level, message, date: DateUtils.moment()}\n    ]);\n  }\n\n  protected async storeLocally() {\n    if (this._saving) return;\n    this._saving = true;\n    try {\n      const newMessages: any[] = (this._dataSubject.value || []).map(LogUtils.asObject);\n\n      if (isEmptyArray(newMessages)) return; // Skip if no data\n      this._dataSubject.next([]); // Reset log\n\n      const oldValue = await this.storage.get(this._storageKey);\n      const oldMessages: any[] = (typeof oldValue === 'string') ? JSON.parse(oldValue) : (oldValue || []);\n      let lastMessages = [\n        ...(oldMessages || []),\n        ...newMessages\n      ];\n      if (lastMessages.length > this._maxMessages) {\n        lastMessages = lastMessages.slice(lastMessages.length - this._maxMessages);\n      }\n\n      if (isNotEmptyArray(lastMessages)) {\n        console.info(`[logging] Saving ${newMessages.length} messages to storage...`);\n        await this.storage.set(this._storageKey, lastMessages);\n      }\n    }\n    catch(err) {\n      console.error(err);\n    }\n    finally {\n      this._saving = false;\n    }\n  }\n}\n"]}

package/{esm2020 → esm2022}/src/app/shared/logging/logging-service.module.mjs

@@ -5,14 +5,14 @@ import { TranslateModule } from '@ngx-translate/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-translate/core";
 export class LoggingServiceModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: LoggingServiceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.6", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
+            IonicModule, i1.TranslateModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
+            IonicModule,
+            TranslateModule.forChild()] });
 }
-LoggingServiceModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LoggingServiceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-LoggingServiceModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
-        IonicModule, i1.TranslateModule] });
-LoggingServiceModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
-        IonicModule,
-        TranslateModule.forChild()] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: LoggingServiceModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: LoggingServiceModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -27,4 +27,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2luZy1zZXJ2aWNlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2xvZ2dpbmcvbG9nZ2luZy1zZXJ2aWNlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0MsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLHFCQUFxQixDQUFDOzs7QUFpQnBELE1BQU0sT0FBTyxvQkFBb0I7O2tIQUFwQixvQkFBb0I7bUhBQXBCLG9CQUFvQixZQWI3QixZQUFZO1FBQ1osV0FBVzttSEFZRixvQkFBb0IsWUFiN0IsWUFBWTtRQUNaLFdBQVc7UUFDWCxlQUFlLENBQUMsUUFBUSxFQUFFOzRGQVdqQixvQkFBb0I7a0JBZmhDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osV0FBVzt3QkFDWCxlQUFlLENBQUMsUUFBUSxFQUFFO3dCQUUxQixzQkFBc0I7cUJBQ3ZCO29CQUNELFlBQVksRUFBRSxFQUViO29CQUNELE9BQU8sRUFBRTtvQkFDUCxzQkFBc0I7cUJBQ3ZCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SW9uaWNNb2R1bGV9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJztcbmltcG9ydCB7VHJhbnNsYXRlTW9kdWxlfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBJb25pY01vZHVsZSxcbiAgICBUcmFuc2xhdGVNb2R1bGUuZm9yQ2hpbGQoKSxcblxuICAgIC8vIFRlc3Rpbmcgc3ViLW1vZHVsZXNcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG5cbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIC8vIFRlc3Rpbmcgc3ViLW1vZHVsZXNcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBMb2dnaW5nU2VydmljZU1vZHVsZSB7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2luZy1zZXJ2aWNlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2xvZ2dpbmcvbG9nZ2luZy1zZXJ2aWNlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0MsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLHFCQUFxQixDQUFDOzs7QUFpQnBELE1BQU0sT0FBTyxvQkFBb0I7dUdBQXBCLG9CQUFvQjt3R0FBcEIsb0JBQW9CLFlBYjdCLFlBQVk7WUFDWixXQUFXO3dHQVlGLG9CQUFvQixZQWI3QixZQUFZO1lBQ1osV0FBVztZQUNYLGVBQWUsQ0FBQyxRQUFRLEVBQUU7OzJGQVdqQixvQkFBb0I7a0JBZmhDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osV0FBVzt3QkFDWCxlQUFlLENBQUMsUUFBUSxFQUFFO3dCQUUxQixzQkFBc0I7cUJBQ3ZCO29CQUNELFlBQVksRUFBRSxFQUViO29CQUNELE9BQU8sRUFBRTtvQkFDUCxzQkFBc0I7cUJBQ3ZCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SW9uaWNNb2R1bGV9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJztcbmltcG9ydCB7VHJhbnNsYXRlTW9kdWxlfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBJb25pY01vZHVsZSxcbiAgICBUcmFuc2xhdGVNb2R1bGUuZm9yQ2hpbGQoKSxcblxuICAgIC8vIFRlc3Rpbmcgc3ViLW1vZHVsZXNcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG5cbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIC8vIFRlc3Rpbmcgc3ViLW1vZHVsZXNcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBMb2dnaW5nU2VydmljZU1vZHVsZSB7XG59XG4iXX0=

package/esm2022/src/app/shared/material/autocomplete/material.autocomplete.config.mjs

@@ -0,0 +1,49 @@
+import { MatAutocompleteFieldUtils } from './material.autocomplete.utils';
+export class MatAutocompleteConfigHolder {
+    options;
+    fields = {};
+    getUserAttributes;
+    constructor(options) {
+        this.options = options;
+        // Store the function from options (e.g. get from user settings)
+        // or create a default function
+        this.getUserAttributes = options?.getUserAttributes ||
+            ((fieldName, defaultAttributes) => defaultAttributes || ['label', 'name']);
+    }
+    add(fieldName, options) {
+        if (!fieldName) {
+            throw new Error('Unable to add config, with name: ' + (fieldName || 'undefined'));
+        }
+        options = options || {};
+        const suggestFn = options.suggestFn
+            || (options.service && ((v, f) => options.service.suggest(v, f)))
+            || undefined;
+        const attributes = (this.getUserAttributes(fieldName, options.attributes) || ['label', 'name']);
+        // Keep original the function from options, when exists
+        const attributesOrFn = attributes.map((a, index) => typeof a === 'function' && options.attributes[index] || a);
+        const filter = {
+            searchAttribute: attributes.length === 1 ? attributes[0] : undefined,
+            searchAttributes: attributes.length > 1 ? attributes : undefined,
+            ...options.filter
+        };
+        const displayWith = options.displayWith || MatAutocompleteFieldUtils.createDisplayFn(attributes, options.multiple);
+        const equals = options.equals || MatAutocompleteFieldUtils.defaultEquals;
+        const config = {
+            ...options,
+            attributes: attributesOrFn,
+            suggestFn,
+            filter,
+            displayWith,
+            equals
+        };
+        this.fields[fieldName] = config;
+        return config;
+    }
+    get(fieldName) {
+        if (!fieldName) {
+            throw new Error('Unable to add config, with name: ' + (fieldName || 'undefined'));
+        }
+        return this.fields[fieldName] || this.add(fieldName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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