@sumaris-net/ngx-components 2.6.26 → 2.7.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ2Vzcy5pbnRlcmNlcHRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2ludGVyY2VwdG9ycy9wcm9nZXNzLmludGVyY2VwdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQ2pELE9BQU8sRUFBd0QsWUFBWSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFMUcsT0FBTyxFQUFFLHdCQUF3QixFQUF1QixNQUFNLGtDQUFrQyxDQUFDO0FBQ2pHLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFaEMsSUFBTSxtQkFBbUIsR0FBekIsTUFBTSxtQkFBbUI7SUFDMEI7SUFBdEQsWUFBc0Qsa0JBQXVDO1FBQXZDLHVCQUFrQixHQUFsQixrQkFBa0IsQ0FBcUI7SUFDN0YsQ0FBQztJQUVELFNBQVMsQ0FBQyxHQUFxQixFQUFFLElBQWlCO1FBQzlDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUNuQyxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxDQUFDO2FBQ3BCLElBQUksQ0FDSCxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDUixJQUFJLEtBQUssWUFBWSxZQUFZLEVBQUUsQ0FBQztnQkFDbEMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3JDLENBQUM7UUFDTCxDQUFDLENBQUMsRUFDRixVQUFVLENBQUMsQ0FBQyxHQUFHLEVBQUUsS0FBSyxFQUFFLEVBQUU7WUFDeEIsSUFBSSxDQUFDLGtCQUFrQixDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ25DLE1BQU0sR0FBRyxDQUFDO1FBQ1osQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUNaLENBQUM7Q0FDSixDQUFBO0FBbEJZLG1CQUFtQjtJQUNmLFdBQUEsTUFBTSxDQUFDLHdCQUF3QixDQUFDLENBQUE7R0FEcEMsbUJBQW1CLENBa0IvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGNhdGNoRXJyb3IsIHRhcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJztcbmltcG9ydCB7IEh0dHBFdmVudCwgSHR0cEhhbmRsZXIsIEh0dHBJbnRlcmNlcHRvciwgSHR0cFJlcXVlc3QsIEh0dHBSZXNwb25zZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEFQUF9QUk9HUkVTU19CQVJfU0VSVklDRSwgSVByb2dyZXNzQmFyU2VydmljZSB9IGZyb20gJy4uL3NlcnZpY2VzL3Byb2dyZXNzLWJhci5zZXJ2aWNlJztcbmltcG9ydCB7IEluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5leHBvcnQgY2xhc3MgUHJvZ3Jlc3NJbnRlcmNlcHRvciBpbXBsZW1lbnRzIEh0dHBJbnRlcmNlcHRvciB7XG4gICAgY29uc3RydWN0b3IoQEluamVjdChBUFBfUFJPR1JFU1NfQkFSX1NFUlZJQ0UpIHByaXZhdGUgcHJvZ3Jlc3NCYXJTZXJ2aWNlOiBJUHJvZ3Jlc3NCYXJTZXJ2aWNlKSB7XG4gICAgfVxuXG4gICAgaW50ZXJjZXB0KHJlcTogSHR0cFJlcXVlc3Q8YW55PiwgbmV4dDogSHR0cEhhbmRsZXIpOiBPYnNlcnZhYmxlPEh0dHBFdmVudDxhbnk+PiB7XG4gICAgICAgIHRoaXMucHJvZ3Jlc3NCYXJTZXJ2aWNlLmluY3JlYXNlKCk7XG4gICAgICAgIHJldHVybiBuZXh0LmhhbmRsZShyZXEpXG4gICAgICAgICAgLnBpcGUoXG4gICAgICAgICAgICB0YXAoZXZlbnQgPT4ge1xuICAgICAgICAgICAgICAgIGlmIChldmVudCBpbnN0YW5jZW9mIEh0dHBSZXNwb25zZSkge1xuICAgICAgICAgICAgICAgICAgdGhpcy5wcm9ncmVzc0JhclNlcnZpY2UuZGVjcmVhc2UoKTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICB9KSxcbiAgICAgICAgICAgIGNhdGNoRXJyb3IoKGVyciwgZXZlbnQpID0+IHtcbiAgICAgICAgICAgICAgdGhpcy5wcm9ncmVzc0JhclNlcnZpY2UuZGVjcmVhc2UoKTtcbiAgICAgICAgICAgICAgdGhyb3cgZXJyO1xuICAgICAgICAgICAgfSkpO1xuICAgIH1cbn1cbiJdfQ==

package/esm2022/src/app/shared/logging/logger.model.mjs

@@ -0,0 +1,47 @@
+import { LogLevel } from './log-level.model';
+import { fromDateISOString, toDateISOString } from '../dates';
+export class LogUtils {
+    static fromObject(source) {
+        const date = fromDateISOString(source.date);
+        return {
+            loggerName: source.loggerName,
+            date,
+            level: source.level || LogLevel.INFO,
+            message: source.message,
+        };
+    }
+    static asObject(source) {
+        const date = toDateISOString(source.date);
+        return {
+            loggerName: source.loggerName,
+            date,
+            level: +source.level,
+            message: source.message
+        };
+    }
+    static fromObjects(sources) {
+        return (sources || []).map(this.fromObject);
+    }
+    static levelToString(level) {
+        return LogLevel[level].toUpperCase();
+    }
+    static levelToColor(level) {
+        switch (level) {
+            case LogLevel.TRACE:
+                return 'primary';
+            case LogLevel.DEBUG:
+                return 'secondary';
+            case LogLevel.INFO:
+                return 'tertiary';
+            case LogLevel.WARN:
+                return 'warning';
+            case LogLevel.ERROR:
+                return 'accent';
+            case LogLevel.FATAL:
+                return 'danger';
+            default:
+                return 'medium';
+        }
+    }
+}
+//# 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.1.1", ngImport: i0, type: LoggingService, deps: [{ token: APP_STORAGE }, { token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: LoggingService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.1", 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.1.1", ngImport: i0, type: LoggingServiceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.1.1", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
+            IonicModule, i1.TranslateModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
+            IonicModule,
+            TranslateModule.forChild()] });
 }
-LoggingServiceModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LoggingServiceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-LoggingServiceModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
-        IonicModule, i1.TranslateModule] });
-LoggingServiceModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LoggingServiceModule, imports: [CommonModule,
-        IonicModule,
-        TranslateModule.forChild()] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: LoggingServiceModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.1", ngImport: i0, type: LoggingServiceModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [
@@ -27,4 +27,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImpor
                     ]
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nZ2luZy1zZXJ2aWNlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvc2hhcmVkL2xvZ2dpbmcvbG9nZ2luZy1zZXJ2aWNlLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsV0FBVyxFQUFDLE1BQU0sZ0JBQWdCLENBQUM7QUFDM0MsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLHFCQUFxQixDQUFDOzs7QUFpQnBELE1BQU0sT0FBTyxvQkFBb0I7O2lIQUFwQixvQkFBb0I7a0hBQXBCLG9CQUFvQixZQWI3QixZQUFZO1FBQ1osV0FBVztrSEFZRixvQkFBb0IsWUFiN0IsWUFBWTtRQUNaLFdBQVc7UUFDWCxlQUFlLENBQUMsUUFBUSxFQUFFOzJGQVdqQixvQkFBb0I7a0JBZmhDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osV0FBVzt3QkFDWCxlQUFlLENBQUMsUUFBUSxFQUFFO3dCQUUxQixzQkFBc0I7cUJBQ3ZCO29CQUNELFlBQVksRUFBRSxFQUViO29CQUNELE9BQU8sRUFBRTtvQkFDUCxzQkFBc0I7cUJBQ3ZCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7SW9uaWNNb2R1bGV9IGZyb20gJ0Bpb25pYy9hbmd1bGFyJztcbmltcG9ydCB7VHJhbnNsYXRlTW9kdWxlfSBmcm9tICdAbmd4LXRyYW5zbGF0ZS9jb3JlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZSxcbiAgICBJb25pY01vZHVsZSxcbiAgICBUcmFuc2xhdGVNb2R1bGUuZm9yQ2hpbGQoKSxcblxuICAgIC8vIFRlc3Rpbmcgc3ViLW1vZHVsZXNcbiAgXSxcbiAgZGVjbGFyYXRpb25zOiBbXG5cbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIC8vIFRlc3Rpbmcgc3ViLW1vZHVsZXNcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBMb2dnaW5nU2VydmljZU1vZHVsZSB7XG59XG4iXX0=
+//# 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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