@porscheinformatik/material-addons 0.0.34 → 0.0.99

package/esm2022/lib/material-addons.module.mjs

@@ -0,0 +1,45 @@
+import { NgModule } from '@angular/core';
+import { ToolbarModule } from './toolbar/toolbar.module';
+import { ReadOnlyFormFieldModule } from './readonly/readonly-form-field.module';
+import { MaterialActionButtonModule } from './material-action-button/material-action-button.module';
+import { NumericFieldModule } from './numeric-field/numeric-field.module';
+import { CardModule } from './card/card.module';
+import { QuickListModule } from './quick-list/quick-list.module';
+import { ButtonModule } from './button/button.module';
+import { ThrottleClickModule } from './throttle-click/throttle-click.module';
+import * as i0 from "@angular/core";
+export class MaterialAddonsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: MaterialAddonsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.4", ngImport: i0, type: MaterialAddonsModule, exports: [ReadOnlyFormFieldModule,
+            ButtonModule,
+            ToolbarModule,
+            MaterialActionButtonModule,
+            NumericFieldModule,
+            CardModule,
+            QuickListModule,
+            ThrottleClickModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: MaterialAddonsModule, imports: [ReadOnlyFormFieldModule,
+            ButtonModule,
+            ToolbarModule,
+            MaterialActionButtonModule,
+            NumericFieldModule,
+            CardModule,
+            QuickListModule,
+            ThrottleClickModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: MaterialAddonsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        ReadOnlyFormFieldModule,
+                        ButtonModule,
+                        ToolbarModule,
+                        MaterialActionButtonModule,
+                        NumericFieldModule,
+                        CardModule,
+                        QuickListModule,
+                        ThrottleClickModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/numeric-field/number-format.service.mjs

@@ -0,0 +1,139 @@
+import { Inject, LOCALE_ID, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NumberFormatService {
+    static { this.NEGATIVE = '-'; }
+    static { this.NUMBERS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']; }
+    static { this.DEFAULT_FINAL_FORMATTING = true; }
+    static { this.DEFAULT_DECIMAL_PLACES = 2; }
+    static { this.DEFAULT_AUTOFILL_DECIMALS = false; }
+    static { this.DEFAULT_REMOVE_LEADING_ZEROS = false; }
+    constructor(locale) {
+        this.allowedKeys = [];
+        // try to get the current formatting
+        const localeDecimalSeparator = (1.1).toLocaleString(locale).charAt(1);
+        this.decimalSeparator = localeDecimalSeparator === ',' ? ',' : '.';
+        this.groupingSeparator = localeDecimalSeparator === ',' ? '.' : ',';
+        this.allowedKeys = [...NumberFormatService.NUMBERS, NumberFormatService.NEGATIVE, this.decimalSeparator];
+    }
+    static valueIsSet(value) {
+        return typeof value !== 'undefined' && value !== null && (typeof value !== 'string' || value.length !== 0);
+    }
+    format(value, options) {
+        return NumberFormatService.valueIsSet(value)
+            ? this.formatNumber(value.toString().replace(new RegExp('[.]', 'g'), this.decimalSeparator), options)
+            : '';
+    }
+    formatNumber(value, options) {
+        const autofillDecimals = this.valueOrDefault(options?.autofillDecimals, NumberFormatService.DEFAULT_AUTOFILL_DECIMALS);
+        const decimalPlaces = this.valueOrDefault(options?.decimalPlaces, NumberFormatService.DEFAULT_DECIMAL_PLACES);
+        const finalFormatting = this.valueOrDefault(options?.finalFormatting, NumberFormatService.DEFAULT_FINAL_FORMATTING);
+        let result = this.strip(value, { decimalPlaces, removeLeadingZeros: finalFormatting });
+        /* add grouping separator */
+        const decimalIndex = result.indexOf(this.decimalSeparator);
+        const isNegative = result.startsWith(NumberFormatService.NEGATIVE);
+        let i = decimalIndex > -1 ? decimalIndex : result.length;
+        while (i > (isNegative ? 4 : 3)) {
+            i -= 3;
+            result = result.substring(0, i) + this.groupingSeparator + result.substring(i, result.length);
+        }
+        if (finalFormatting) {
+            if (decimalPlaces > 0 && !!result) {
+                /* autofill decimal places */
+                let actualDecimalIndex = result.indexOf(this.decimalSeparator);
+                if (autofillDecimals) {
+                    if (actualDecimalIndex === -1) {
+                        actualDecimalIndex = result.length;
+                        result += this.decimalSeparator;
+                    }
+                    result = this.addMissingLeadingZero(result, actualDecimalIndex);
+                    actualDecimalIndex = result.indexOf(this.decimalSeparator);
+                    const actualDecimalPlaces = result.length - actualDecimalIndex - 1;
+                    for (let j = 0; j < decimalPlaces - actualDecimalPlaces; j++) {
+                        result += '0';
+                    }
+                }
+                else {
+                    result = this.addMissingLeadingZero(result, actualDecimalIndex);
+                }
+            }
+        }
+        return result;
+    }
+    strip(value, options) {
+        const decimalPlaces = this.valueOrDefault(options?.decimalPlaces, NumberFormatService.DEFAULT_DECIMAL_PLACES);
+        const removeLeadingZeros = this.valueOrDefault(options?.removeLeadingZeros, NumberFormatService.DEFAULT_REMOVE_LEADING_ZEROS);
+        let result = '';
+        let indexDecimalSep = -1;
+        let j = -1;
+        let ignoredChars = 0;
+        for (const char of value) {
+            j++;
+            if (this.allowedKeys.includes(char)) {
+                if (char === this.decimalSeparator) {
+                    if (decimalPlaces === 0) {
+                        /* dismiss content after a decimal separator, when no places allowed */
+                        break;
+                    }
+                    else if (indexDecimalSep > -1) {
+                        /* ignore subsequent decimal separators */
+                        continue;
+                    }
+                    indexDecimalSep = j;
+                }
+                if (char === '0' && removeLeadingZeros) {
+                    /* remove leading zero only if it's not the only zero in the 'value' string */
+                    if ((result.length === 0 && j + 1 !== value.length) || result === NumberFormatService.NEGATIVE) {
+                        ignoredChars++;
+                        continue;
+                    }
+                }
+                if (char === NumberFormatService.NEGATIVE && j > 0) {
+                    /* dismiss content after a negative sign not on first position */
+                    break;
+                }
+                if (indexDecimalSep > -1 && result.length + ignoredChars > indexDecimalSep + decimalPlaces) {
+                    /* dismiss content after maximum decimal places reached */
+                    break;
+                }
+                result += char;
+            }
+            else if (char === this.groupingSeparator) {
+                if (indexDecimalSep === -1) {
+                    ignoredChars++;
+                }
+            }
+            else {
+                /* dismiss content after a invalid character */
+                break;
+            }
+        }
+        return result;
+    }
+    addMissingLeadingZero(result, actualDecimalIndex) {
+        const isNegative = result.startsWith(NumberFormatService.NEGATIVE);
+        /* autoadd a zero before decimal separator, when it's missing */
+        if (actualDecimalIndex === 0) {
+            result = '0' + result;
+        }
+        /* autoadd a zero before decimal separator, when it's missing, for negative values */
+        if (actualDecimalIndex === 1 && isNegative) {
+            result = result[0] + '0' + result.substring(1, result.length);
+        }
+        return result;
+    }
+    valueOrDefault(value, defaultValue) {
+        return NumberFormatService.valueIsSet(value) ? value : defaultValue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumberFormatService, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumberFormatService, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumberFormatService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"number-format.service.js","sourceRoot":"","sources":["../../../../../projects/material-addons/src/lib/numeric-field/number-format.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, LOCALE_ID, Injectable } from '@angular/core';\n\nexport declare interface FormatOptions {\n  decimalPlaces?: number;\n\n  finalFormatting?: boolean;\n\n  autofillDecimals?: boolean;\n}\n\nexport declare interface StripOptions {\n  decimalPlaces?: number;\n\n  removeLeadingZeros?: boolean;\n}\n\n@Injectable({\n  providedIn: 'any',\n})\nexport class NumberFormatService {\n  static readonly NEGATIVE = '-';\n  static readonly NUMBERS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];\n  static readonly DEFAULT_FINAL_FORMATTING = true;\n  static readonly DEFAULT_DECIMAL_PLACES = 2;\n  static readonly DEFAULT_AUTOFILL_DECIMALS = false;\n  static readonly DEFAULT_REMOVE_LEADING_ZEROS = false;\n\n  decimalSeparator: ',' | '.';\n  groupingSeparator: ',' | '.';\n\n  allowedKeys: string[] = [];\n\n  constructor(@Inject(LOCALE_ID) locale: string) {\n    // try to get the current formatting\n    const localeDecimalSeparator = (1.1).toLocaleString(locale).charAt(1);\n    this.decimalSeparator = localeDecimalSeparator === ',' ? ',' : '.';\n    this.groupingSeparator = localeDecimalSeparator === ',' ? '.' : ',';\n\n    this.allowedKeys = [...NumberFormatService.NUMBERS, NumberFormatService.NEGATIVE, this.decimalSeparator];\n  }\n\n  static valueIsSet(value: any): boolean {\n    return typeof value !== 'undefined' && value !== null && (typeof value !== 'string' || value.length !== 0);\n  }\n\n  format(value: number, options?: Partial<FormatOptions>): string {\n    return NumberFormatService.valueIsSet(value)\n      ? this.formatNumber(value.toString().replace(new RegExp('[.]', 'g'), this.decimalSeparator), options)\n      : '';\n  }\n\n  formatNumber(value: string, options?: Partial<FormatOptions>): string {\n    const autofillDecimals = this.valueOrDefault(options?.autofillDecimals, NumberFormatService.DEFAULT_AUTOFILL_DECIMALS);\n    const decimalPlaces = this.valueOrDefault(options?.decimalPlaces, NumberFormatService.DEFAULT_DECIMAL_PLACES);\n    const finalFormatting = this.valueOrDefault(options?.finalFormatting, NumberFormatService.DEFAULT_FINAL_FORMATTING);\n\n    let result = this.strip(value, { decimalPlaces, removeLeadingZeros: finalFormatting });\n\n    /* add grouping separator */\n    const decimalIndex = result.indexOf(this.decimalSeparator);\n    const isNegative = result.startsWith(NumberFormatService.NEGATIVE);\n    let i = decimalIndex > -1 ? decimalIndex : result.length;\n    while (i > (isNegative ? 4 : 3)) {\n      i -= 3;\n      result = result.substring(0, i) + this.groupingSeparator + result.substring(i, result.length);\n    }\n\n    if (finalFormatting) {\n      if (decimalPlaces > 0 && !!result) {\n        /* autofill decimal places */\n        let actualDecimalIndex = result.indexOf(this.decimalSeparator);\n        if (autofillDecimals) {\n          if (actualDecimalIndex === -1) {\n            actualDecimalIndex = result.length;\n            result += this.decimalSeparator;\n          }\n\n          result = this.addMissingLeadingZero(result, actualDecimalIndex);\n          actualDecimalIndex = result.indexOf(this.decimalSeparator);\n\n          const actualDecimalPlaces = result.length - actualDecimalIndex - 1;\n          for (let j = 0; j < decimalPlaces - actualDecimalPlaces; j++) {\n            result += '0';\n          }\n        } else {\n          result = this.addMissingLeadingZero(result, actualDecimalIndex);\n        }\n      }\n    }\n    return result;\n  }\n\n  strip(value: string, options?: StripOptions): string {\n    const decimalPlaces = this.valueOrDefault(options?.decimalPlaces, NumberFormatService.DEFAULT_DECIMAL_PLACES);\n    const removeLeadingZeros = this.valueOrDefault(options?.removeLeadingZeros, NumberFormatService.DEFAULT_REMOVE_LEADING_ZEROS);\n\n    let result = '';\n    let indexDecimalSep = -1;\n    let j = -1;\n    let ignoredChars = 0;\n    for (const char of value) {\n      j++;\n      if (this.allowedKeys.includes(char)) {\n        if (char === this.decimalSeparator) {\n          if (decimalPlaces === 0) {\n            /* dismiss content after a decimal separator, when no places allowed */\n            break;\n          } else if (indexDecimalSep > -1) {\n            /* ignore subsequent decimal separators */\n            continue;\n          }\n          indexDecimalSep = j;\n        }\n        if (char === '0' && removeLeadingZeros) {\n          /* remove leading zero only if it's not the only zero in the 'value' string */\n          if ((result.length === 0 && j + 1 !== value.length) || result === NumberFormatService.NEGATIVE) {\n            ignoredChars++;\n            continue;\n          }\n        }\n        if (char === NumberFormatService.NEGATIVE && j > 0) {\n          /* dismiss content after a negative sign not on first position */\n          break;\n        }\n        if (indexDecimalSep > -1 && result.length + ignoredChars > indexDecimalSep + decimalPlaces) {\n          /* dismiss content after maximum decimal places reached */\n          break;\n        }\n        result += char;\n      } else if (char === this.groupingSeparator) {\n        if (indexDecimalSep === -1) {\n          ignoredChars++;\n        }\n      } else {\n        /* dismiss content after a invalid character */\n        break;\n      }\n    }\n    return result;\n  }\n\n  private addMissingLeadingZero(result: string, actualDecimalIndex: number): string {\n    const isNegative = result.startsWith(NumberFormatService.NEGATIVE);\n    /* autoadd a zero before decimal separator, when it's missing */\n    if (actualDecimalIndex === 0) {\n      result = '0' + result;\n    }\n    /* autoadd a zero before decimal separator, when it's missing, for negative values */\n    if (actualDecimalIndex === 1 && isNegative) {\n      result = result[0] + '0' + result.substring(1, result.length);\n    }\n    return result;\n  }\n\n  private valueOrDefault(value: any, defaultValue: any): any {\n    return NumberFormatService.valueIsSet(value) ? value : defaultValue;\n  }\n}\n"]}

package/esm2022/lib/numeric-field/numeric-field.directive.mjs

@@ -0,0 +1,295 @@
+/*
+ * Copyright (c) 2018-2020 Porsche Informatik. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Directive, EventEmitter, forwardRef, Input, Output, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { NumberFormatService } from './number-format.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./number-format.service";
+const BACK_KEYCODE = 8;
+const SPACE_KEYCODE = 32;
+const DEL_KEYCODE = 46;
+const CONTROL_KEYCODES_UPPER_BORDER = 46;
+const OTHER_CONTROL_KEYS = new Set([224, 91, 93]);
+export class NumericFieldDirective {
+    set numericValue(value) {
+        if (this._numericValue !== value && !(isNaN(this._numericValue) && (isNaN(value) || value === null))) {
+            this.originalValue = value;
+            // Don't roundOrTruncate if value was set to empty otherwise input value will be set to 0 instead of empty
+            // which happens when an input is being reset
+            this._numericValue = value === null || value === undefined ? value : this.roundOrTruncate(value); // eslint-disable-line
+            this.handleInputChanged();
+        }
+    }
+    constructor(renderer, inputEl, numberFormatService) {
+        this.renderer = renderer;
+        this.inputEl = inputEl;
+        this.numberFormatService = numberFormatService;
+        this.textAlign = 'right';
+        this.decimalPlaces = 2;
+        this.roundValue = false;
+        this.autofillDecimals = false;
+        this.unit = null;
+        this.unitPosition = 'right';
+        this.numericValueChanged = new EventEmitter();
+        this.displayValue = '';
+        this.originalValue = NaN;
+        /* Control Values Accessor Stuff below */
+        // eslint-disable-next-line
+        this.onChange = () => { };
+        // eslint-disable-next-line
+        this.onTouched = () => { };
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState() {
+        // Dont need to implement since its just a directive
+    }
+    writeValue(value) {
+        this.numericValue = value;
+    }
+    ngOnInit() {
+        /* needs to be parsed as number explicitly as it comes as string from user input */
+        this.decimalPlaces = parseInt(this.decimalPlaces.toString(), 10);
+        this.inputChangeListener = this.renderer.listen(this.inputEl.nativeElement, 'blur', (event) => {
+            this.formatInput(event.target, true);
+        });
+        this.keyupListener = this.renderer.listen(this.inputEl.nativeElement, 'keyup', (event) => {
+            if (event.keyCode === BACK_KEYCODE || (event.keyCode >= CONTROL_KEYCODES_UPPER_BORDER && !OTHER_CONTROL_KEYS.has(event.keyCode))) {
+                this.formatInput(event.target, false);
+            }
+        });
+        this.keydownListener = this.renderer.listen(this.inputEl.nativeElement, 'keydown', (event) => {
+            const value = event.target.value;
+            if (this.numberFormatService.allowedKeys.includes(event.key) ||
+                (event.keyCode <= CONTROL_KEYCODES_UPPER_BORDER && event.keyCode > 0 && event.keyCode !== SPACE_KEYCODE) ||
+                event.metaKey ||
+                event.ctrlKey ||
+                event.altKey) {
+                /* allow negative sign only as first character and none exists outside of text selection */
+                const indexNegativeSign = value.indexOf(NumberFormatService.NEGATIVE);
+                if (event.key === NumberFormatService.NEGATIVE &&
+                    (event.target.selectionStart > 0 || indexNegativeSign > -1) &&
+                    (event.target.selectionStart === event.target.selectionEnd ||
+                        !(indexNegativeSign >= event.target.selectionStart && indexNegativeSign <= event.target.selectionEnd))) {
+                    return false;
+                }
+                /* no duplicate decimal separators */
+                const indexDecimalSep = value.indexOf(this.numberFormatService.decimalSeparator);
+                if (event.key === this.numberFormatService.decimalSeparator &&
+                    (indexDecimalSep > -1 || this.decimalPlaces === 0) &&
+                    (event.target.selectionStart === event.target.selectionEnd ||
+                        !(indexDecimalSep >= event.target.selectionStart && indexDecimalSep <= event.target.selectionEnd))) {
+                    return false;
+                }
+                /* prevent too many decimal places */
+                if (NumberFormatService.NUMBERS.includes(event.key) &&
+                    indexDecimalSep > -1 &&
+                    indexDecimalSep < event.target.selectionStart &&
+                    event.target.selectionStart === event.target.selectionEnd &&
+                    value.length > indexDecimalSep + this.decimalPlaces) {
+                    return false;
+                }
+                /* when deleting thousand separator, remove the digit before or after it */
+                const cursorStart = event.target.selectionStart;
+                if (cursorStart === event.target.selectionEnd) {
+                    if (event.keyCode === BACK_KEYCODE && value.substr(cursorStart - 1, 1) === this.numberFormatService.groupingSeparator) {
+                        event.target.value = value.substring(0, cursorStart - 2) + value.substring(cursorStart - 1, value.length);
+                        event.target.selectionStart = event.target.selectionEnd = cursorStart - 1;
+                        return false;
+                    }
+                    else if (event.keyCode === DEL_KEYCODE && value.substr(cursorStart, 1) === this.numberFormatService.groupingSeparator) {
+                        event.target.value = value.substring(0, cursorStart + 1) + value.substring(cursorStart + 2, value.length);
+                        event.target.selectionStart = event.target.selectionEnd = cursorStart + 1;
+                        return false;
+                    }
+                }
+                this.originalValue = NaN;
+            }
+            else {
+                return false;
+            }
+            return true;
+        });
+    }
+    ngOnDestroy() {
+        this.detachListener();
+    }
+    ngAfterViewChecked() {
+        this.injectUnitSymbol();
+    }
+    handleInputChanged() {
+        // Call in set timeout to avoid Expression has changed after it has been checked error.
+        // Sometimes the value changes because we cut off decimal places
+        setTimeout(() => {
+            this.updateInput(this.numberFormatService.format(this._numericValue, {
+                decimalPlaces: this.decimalPlaces,
+                finalFormatting: false,
+                autofillDecimals: this.autofillDecimals,
+            }));
+        }, 1);
+    }
+    formatInput(element, finalFormatting) {
+        const cursorPos = element.selectionStart;
+        const length = element.value.length;
+        const setCursor = this.displayValue !== element.value;
+        const textFormatted = this.numberFormatService.formatNumber(element.value, {
+            decimalPlaces: this.decimalPlaces,
+            finalFormatting,
+            autofillDecimals: this.autofillDecimals,
+        });
+        // special handling to move unit symbol along with display value
+        if (this.textAlign === 'left' && this.unitPosition === 'right') {
+            const inputStyles = window.getComputedStyle(this.inputEl.nativeElement.parentElement, null);
+            this.unitSpan.style.position = 'absolute';
+            this.unitSpan.style.marginTop = inputStyles.getPropertyValue('border-top-width');
+            this.unitSpan.style.paddingTop = inputStyles.getPropertyValue('padding-top');
+            this.unitSpan.style.paddingBottom = inputStyles.getPropertyValue('padding-bottom');
+            if (!this.textSpan) {
+                this.textSpan = document.createElement('span');
+                document.body.appendChild(this.textSpan);
+                this.textSpan.style.font = inputStyles.getPropertyValue('font');
+                this.textSpan.style.fontSize = inputStyles.getPropertyValue('font-size');
+                this.textSpan.style.height = 'auto';
+                this.textSpan.style.width = 'auto';
+                this.textSpan.style.position = 'absolute';
+                this.textSpan.style.top = '0';
+                this.textSpan.style.whiteSpace = 'no-wrap';
+                this.textSpan.style.visibility = 'hidden';
+            }
+            this.textSpan.innerHTML = textFormatted;
+            const width = Math.min(this.inputEl.nativeElement.clientWidth - this.unitSpan.clientWidth, Math.ceil(this.textSpan.clientWidth));
+            this.unitSpan.style.left = width + 'px';
+        }
+        this.updateInput(textFormatted);
+        if (setCursor) {
+            element.selectionStart = element.selectionEnd = Math.max(cursorPos + element.value.length - length, 0);
+        }
+    }
+    updateInput(value) {
+        this.displayValue = value;
+        this.inputEl.nativeElement.value = value;
+        this._numericValue = parseFloat(this.numberFormatService.strip(value, { decimalPlaces: this.decimalPlaces }).replace(this.numberFormatService.decimalSeparator, '.'));
+        if (this._numericValue !== this.roundOrTruncate(this.originalValue)) {
+            this.originalValue = this._numericValue;
+            this.numericValueChanged.emit(this._numericValue);
+        }
+    }
+    getValueForFormControl() {
+        this.formatInput(this.inputEl.nativeElement, false);
+        if (isNaN(this._numericValue)) {
+            // Return undefined instead of NaN to support the default required validator.
+            return undefined; // eslint-disable-line
+        }
+        return this._numericValue;
+    }
+    injectUnitSymbol() {
+        // Need to inject the unit symbol when the input element width is set to its actual value,
+        // otherwise the icon wont show in the correct position
+        if (!!this.unit && !this.unitSpan && this.inputEl.nativeElement.offsetWidth !== 0) {
+            // Get the input wrapper and apply necessary styles
+            const inputWrapper = this.inputEl.nativeElement.parentNode.parentNode;
+            // Create the span with unit symbol and apply necessary styles
+            this.unitSpan = this.renderer.createElement('span');
+            if (this.unitPosition === 'left') {
+                this.renderer.setAttribute(this.unitSpan, 'matPrefix', '');
+                this.renderer.setStyle(this.unitSpan, 'padding-right', '5px');
+                this.renderer.insertBefore(inputWrapper, this.unitSpan, inputWrapper.children[0]);
+            }
+            else {
+                this.renderer.setAttribute(this.unitSpan, 'matSuffix', '');
+                this.renderer.setStyle(this.unitSpan, 'padding-left', '5px');
+                this.renderer.appendChild(inputWrapper, this.unitSpan);
+            }
+        }
+        // do not display unit symbol if the unit should move along display value
+        if (!!this.unitSpan && this.textAlign === 'left' && this.unitPosition === 'right') {
+            if (NumberFormatService.valueIsSet(this.displayValue)) {
+                this.unitSpan.style.display = 'unset';
+            }
+            else {
+                this.unitSpan.style.display = 'none';
+            }
+        }
+        // always reset unit symbol
+        if (!!this.unitSpan) {
+            this.unitSpan.textContent = this.unit;
+        }
+    }
+    detachListener() {
+        if (this.inputChangeListener) {
+            this.inputChangeListener();
+            delete this.inputChangeListener;
+        }
+        if (this.keydownListener) {
+            this.keydownListener();
+            delete this.keydownListener;
+        }
+        if (this.keyupListener) {
+            this.keyupListener();
+            delete this.keyupListener;
+        }
+    }
+    roundOrTruncate(value) {
+        const method = this.roundValue ? 'round' : value < 0 ? 'ceil' : 'floor';
+        return Math[method](value * Math.pow(10, this.decimalPlaces)) / Math.pow(10, this.decimalPlaces);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumericFieldDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.NumberFormatService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.4", type: NumericFieldDirective, selector: "[madNumericField]", inputs: { textAlign: "textAlign", decimalPlaces: "decimalPlaces", roundValue: ["roundDisplayValue", "roundValue"], autofillDecimals: "autofillDecimals", unit: "unit", unitPosition: "unitPosition", numericValue: "numericValue" }, outputs: { numericValueChanged: "numericValueChange" }, host: { listeners: { "change": "onChange(getValueForFormControl())", "input": "onChange(getValueForFormControl())", "blur": "onTouched()" }, properties: { "class.text-right": "textAlign === \"right\"" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => NumericFieldDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumericFieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[madNumericField]',
+                    host: {
+                        '[class.text-right]': 'textAlign === "right"',
+                        '(change)': 'onChange(getValueForFormControl())',
+                        '(input)': 'onChange(getValueForFormControl())',
+                        '(blur)': 'onTouched()',
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => NumericFieldDirective),
+                            multi: true,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.NumberFormatService }], propDecorators: { textAlign: [{
+                type: Input,
+                args: ['textAlign']
+            }], decimalPlaces: [{
+                type: Input,
+                args: ['decimalPlaces']
+            }], roundValue: [{
+                type: Input,
+                args: ['roundDisplayValue']
+            }], autofillDecimals: [{
+                type: Input,
+                args: ['autofillDecimals']
+            }], unit: [{
+                type: Input,
+                args: ['unit']
+            }], unitPosition: [{
+                type: Input,
+                args: ['unitPosition']
+            }], numericValueChanged: [{
+                type: Output,
+                args: ['numericValueChange']
+            }], numericValue: [{
+                type: Input,
+                args: ['numericValue']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"numeric-field.directive.js","sourceRoot":"","sources":["../../../../../projects/material-addons/src/lib/numeric-field/numeric-field.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2018-2020 Porsche Informatik. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport {\n  AfterViewChecked,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { NumberFormatService } from './number-format.service';\n\nconst BACK_KEYCODE = 8;\nconst SPACE_KEYCODE = 32;\nconst DEL_KEYCODE = 46;\nconst CONTROL_KEYCODES_UPPER_BORDER = 46;\nconst OTHER_CONTROL_KEYS = new Set([224, 91, 93]);\n\n@Directive({\n  selector: '[madNumericField]',\n  host: {\n    '[class.text-right]': 'textAlign === \"right\"',\n    '(change)': 'onChange(getValueForFormControl())',\n    '(input)': 'onChange(getValueForFormControl())',\n    '(blur)': 'onTouched()',\n  },\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => NumericFieldDirective), // eslint-disable-line\n      multi: true,\n    },\n  ],\n})\nexport class NumericFieldDirective implements OnInit, OnDestroy, AfterViewChecked, ControlValueAccessor {\n  @Input('textAlign') textAlign: 'right' | 'left' = 'right';\n  @Input('decimalPlaces') decimalPlaces = 2;\n  @Input('roundDisplayValue') roundValue = false;\n  @Input('autofillDecimals') autofillDecimals = false;\n  @Input('unit') unit: string | null = null;\n  @Input('unitPosition') unitPosition: 'right' | 'left' = 'right';\n  @Output('numericValueChange') numericValueChanged = new EventEmitter<number>();\n\n  private displayValue = '';\n  private originalValue = NaN;\n  private _numericValue: number;\n  private inputChangeListener: () => void;\n  private keyupListener: () => void;\n  private keydownListener: () => void;\n\n  @Input('numericValue')\n  set numericValue(value: number) {\n    if (this._numericValue !== value && !(isNaN(this._numericValue) && (isNaN(value) || value === null))) {\n      this.originalValue = value;\n      // Don't roundOrTruncate if value was set to empty otherwise input value will be set to 0 instead of empty\n      // which happens when an input is being reset\n      this._numericValue = value === null || value === undefined ? value : this.roundOrTruncate(value); // eslint-disable-line\n      this.handleInputChanged();\n    }\n  }\n\n  private unitSpan: HTMLSpanElement;\n  private textSpan: HTMLSpanElement;\n\n  constructor(\n    private renderer: Renderer2,\n    private inputEl: ElementRef,\n    private numberFormatService: NumberFormatService,\n  ) {}\n\n  /* Control Values Accessor Stuff below */\n  // eslint-disable-next-line\n  onChange: any = () => {};\n  // eslint-disable-next-line\n  onTouched: any = () => {};\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(): void {\n    // Dont need to implement since its just a directive\n  }\n\n  writeValue(value: number): void {\n    this.numericValue = value;\n  }\n\n  ngOnInit(): void {\n    /* needs to be parsed as number explicitly as it comes as string from user input */\n    this.decimalPlaces = parseInt(this.decimalPlaces.toString(), 10);\n\n    this.inputChangeListener = this.renderer.listen(this.inputEl.nativeElement, 'blur', (event) => {\n      this.formatInput(event.target, true);\n    });\n\n    this.keyupListener = this.renderer.listen(this.inputEl.nativeElement, 'keyup', (event) => {\n      if (event.keyCode === BACK_KEYCODE || (event.keyCode >= CONTROL_KEYCODES_UPPER_BORDER && !OTHER_CONTROL_KEYS.has(event.keyCode))) {\n        this.formatInput(event.target, false);\n      }\n    });\n\n    this.keydownListener = this.renderer.listen(this.inputEl.nativeElement, 'keydown', (event) => {\n      const value: string = event.target.value;\n      if (\n        this.numberFormatService.allowedKeys.includes(event.key) ||\n        (event.keyCode <= CONTROL_KEYCODES_UPPER_BORDER && event.keyCode > 0 && event.keyCode !== SPACE_KEYCODE) ||\n        event.metaKey ||\n        event.ctrlKey ||\n        event.altKey\n      ) {\n        /* allow negative sign only as first character and none exists outside of text selection */\n        const indexNegativeSign = value.indexOf(NumberFormatService.NEGATIVE);\n        if (\n          event.key === NumberFormatService.NEGATIVE &&\n          (event.target.selectionStart > 0 || indexNegativeSign > -1) &&\n          (event.target.selectionStart === event.target.selectionEnd ||\n            !(indexNegativeSign >= event.target.selectionStart && indexNegativeSign <= event.target.selectionEnd))\n        ) {\n          return false;\n        }\n\n        /* no duplicate decimal separators */\n        const indexDecimalSep = value.indexOf(this.numberFormatService.decimalSeparator);\n        if (\n          event.key === this.numberFormatService.decimalSeparator &&\n          (indexDecimalSep > -1 || this.decimalPlaces === 0) &&\n          (event.target.selectionStart === event.target.selectionEnd ||\n            !(indexDecimalSep >= event.target.selectionStart && indexDecimalSep <= event.target.selectionEnd))\n        ) {\n          return false;\n        }\n\n        /* prevent too many decimal places */\n        if (\n          NumberFormatService.NUMBERS.includes(event.key) &&\n          indexDecimalSep > -1 &&\n          indexDecimalSep < event.target.selectionStart &&\n          event.target.selectionStart === event.target.selectionEnd &&\n          value.length > indexDecimalSep + this.decimalPlaces\n        ) {\n          return false;\n        }\n\n        /* when deleting thousand separator, remove the digit before or after it */\n        const cursorStart = event.target.selectionStart;\n\n        if (cursorStart === event.target.selectionEnd) {\n          if (event.keyCode === BACK_KEYCODE && value.substr(cursorStart - 1, 1) === this.numberFormatService.groupingSeparator) {\n            event.target.value = value.substring(0, cursorStart - 2) + value.substring(cursorStart - 1, value.length);\n            event.target.selectionStart = event.target.selectionEnd = cursorStart - 1;\n            return false;\n          } else if (event.keyCode === DEL_KEYCODE && value.substr(cursorStart, 1) === this.numberFormatService.groupingSeparator) {\n            event.target.value = value.substring(0, cursorStart + 1) + value.substring(cursorStart + 2, value.length);\n            event.target.selectionStart = event.target.selectionEnd = cursorStart + 1;\n            return false;\n          }\n        }\n        this.originalValue = NaN;\n      } else {\n        return false;\n      }\n      return true;\n    });\n  }\n\n  ngOnDestroy(): void {\n    this.detachListener();\n  }\n\n  ngAfterViewChecked(): void {\n    this.injectUnitSymbol();\n  }\n\n  handleInputChanged(): void {\n    // Call in set timeout to avoid Expression has changed after it has been checked error.\n    // Sometimes the value changes because we cut off decimal places\n    setTimeout(() => {\n      this.updateInput(\n        this.numberFormatService.format(this._numericValue, {\n          decimalPlaces: this.decimalPlaces,\n          finalFormatting: false,\n          autofillDecimals: this.autofillDecimals,\n        }),\n      );\n    }, 1);\n  }\n\n  formatInput(element: HTMLInputElement, finalFormatting: boolean): void {\n    const cursorPos = element.selectionStart;\n    const length = element.value.length;\n    const setCursor = this.displayValue !== element.value;\n    const textFormatted = this.numberFormatService.formatNumber(element.value, {\n      decimalPlaces: this.decimalPlaces,\n      finalFormatting,\n      autofillDecimals: this.autofillDecimals,\n    });\n\n    // special handling to move unit symbol along with display value\n    if (this.textAlign === 'left' && this.unitPosition === 'right') {\n      const inputStyles = window.getComputedStyle(this.inputEl.nativeElement.parentElement, null);\n      this.unitSpan.style.position = 'absolute';\n      this.unitSpan.style.marginTop = inputStyles.getPropertyValue('border-top-width');\n      this.unitSpan.style.paddingTop = inputStyles.getPropertyValue('padding-top');\n      this.unitSpan.style.paddingBottom = inputStyles.getPropertyValue('padding-bottom');\n\n      if (!this.textSpan) {\n        this.textSpan = document.createElement('span');\n        document.body.appendChild(this.textSpan);\n        this.textSpan.style.font = inputStyles.getPropertyValue('font');\n        this.textSpan.style.fontSize = inputStyles.getPropertyValue('font-size');\n        this.textSpan.style.height = 'auto';\n        this.textSpan.style.width = 'auto';\n        this.textSpan.style.position = 'absolute';\n        this.textSpan.style.top = '0';\n        this.textSpan.style.whiteSpace = 'no-wrap';\n        this.textSpan.style.visibility = 'hidden';\n      }\n      this.textSpan.innerHTML = textFormatted;\n      const width = Math.min(this.inputEl.nativeElement.clientWidth - this.unitSpan.clientWidth, Math.ceil(this.textSpan.clientWidth));\n      this.unitSpan.style.left = width + 'px';\n    }\n\n    this.updateInput(textFormatted);\n    if (setCursor) {\n      element.selectionStart = element.selectionEnd = Math.max(cursorPos + element.value.length - length, 0);\n    }\n  }\n\n  updateInput(value: string): void {\n    this.displayValue = value;\n    this.inputEl.nativeElement.value = value;\n    this._numericValue = parseFloat(\n      this.numberFormatService.strip(value, { decimalPlaces: this.decimalPlaces }).replace(this.numberFormatService.decimalSeparator, '.'),\n    );\n    if (this._numericValue !== this.roundOrTruncate(this.originalValue)) {\n      this.originalValue = this._numericValue;\n      this.numericValueChanged.emit(this._numericValue);\n    }\n  }\n\n  getValueForFormControl(): number | undefined {\n    this.formatInput(this.inputEl.nativeElement, false);\n    if (isNaN(this._numericValue)) {\n      // Return undefined instead of NaN to support the default required validator.\n      return undefined; // eslint-disable-line\n    }\n    return this._numericValue;\n  }\n\n  private injectUnitSymbol(): void {\n    // Need to inject the unit symbol when the input element width is set to its actual value,\n    // otherwise the icon wont show in the correct position\n    if (!!this.unit && !this.unitSpan && this.inputEl.nativeElement.offsetWidth !== 0) {\n      // Get the input wrapper and apply necessary styles\n      const inputWrapper = this.inputEl.nativeElement.parentNode.parentNode;\n\n      // Create the span with unit symbol and apply necessary styles\n      this.unitSpan = this.renderer.createElement('span');\n\n      if (this.unitPosition === 'left') {\n        this.renderer.setAttribute(this.unitSpan, 'matPrefix', '');\n        this.renderer.setStyle(this.unitSpan, 'padding-right', '5px');\n        this.renderer.insertBefore(inputWrapper, this.unitSpan, inputWrapper.children[0]);\n      } else {\n        this.renderer.setAttribute(this.unitSpan, 'matSuffix', '');\n        this.renderer.setStyle(this.unitSpan, 'padding-left', '5px');\n        this.renderer.appendChild(inputWrapper, this.unitSpan);\n      }\n    }\n\n    // do not display unit symbol if the unit should move along display value\n    if (!!this.unitSpan && this.textAlign === 'left' && this.unitPosition === 'right') {\n      if (NumberFormatService.valueIsSet(this.displayValue)) {\n        this.unitSpan.style.display = 'unset';\n      } else {\n        this.unitSpan.style.display = 'none';\n      }\n    }\n    // always reset unit symbol\n    if (!!this.unitSpan) {\n      this.unitSpan.textContent = this.unit;\n    }\n  }\n\n  private detachListener(): void {\n    if (this.inputChangeListener) {\n      this.inputChangeListener();\n      delete this.inputChangeListener;\n    }\n    if (this.keydownListener) {\n      this.keydownListener();\n      delete this.keydownListener;\n    }\n    if (this.keyupListener) {\n      this.keyupListener();\n      delete this.keyupListener;\n    }\n  }\n\n  private roundOrTruncate(value: number): number {\n    const method = this.roundValue ? 'round' : value < 0 ? 'ceil' : 'floor';\n    return Math[method](value * Math.pow(10, this.decimalPlaces)) / Math.pow(10, this.decimalPlaces);\n  }\n}\n"]}

package/esm2022/lib/numeric-field/numeric-field.mjs

@@ -0,0 +1,2 @@
+export { NumericFieldDirective } from './numeric-field.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtZXJpYy1maWVsZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL21hdGVyaWFsLWFkZG9ucy9zcmMvbGliL251bWVyaWMtZmllbGQvbnVtZXJpYy1maWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IE51bWVyaWNGaWVsZERpcmVjdGl2ZSB9IGZyb20gJy4vbnVtZXJpYy1maWVsZC5kaXJlY3RpdmUnO1xuIl19

package/esm2022/lib/numeric-field/numeric-field.module.mjs

@@ -0,0 +1,24 @@
+import { NgModule } from '@angular/core';
+import { NumericFieldDirective } from './numeric-field.directive';
+import { NumberFormatService } from './number-format.service';
+import * as i0 from "@angular/core";
+export class NumericFieldModule {
+    static forRoot() {
+        return {
+            ngModule: NumericFieldModule,
+            providers: [NumberFormatService],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumericFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.4", ngImport: i0, type: NumericFieldModule, declarations: [NumericFieldDirective], exports: [NumericFieldDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumericFieldModule, providers: [NumberFormatService] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.4", ngImport: i0, type: NumericFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [NumberFormatService],
+                    declarations: [NumericFieldDirective],
+                    exports: [NumericFieldDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtZXJpYy1maWVsZC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tYXRlcmlhbC1hZGRvbnMvc3JjL2xpYi9udW1lcmljLWZpZWxkL251bWVyaWMtZmllbGQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQXVCLE1BQU0sZUFBZSxDQUFDO0FBQzlELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQU85RCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLE1BQU0sQ0FBQyxPQUFPO1FBQ1osT0FBTztZQUNMLFFBQVEsRUFBRSxrQkFBa0I7WUFDNUIsU0FBUyxFQUFFLENBQUMsbUJBQW1CLENBQUM7U0FDakMsQ0FBQztJQUNKLENBQUM7OEdBTlUsa0JBQWtCOytHQUFsQixrQkFBa0IsaUJBSGQscUJBQXFCLGFBQzFCLHFCQUFxQjsrR0FFcEIsa0JBQWtCLGFBSmxCLENBQUMsbUJBQW1CLENBQUM7OzJGQUlyQixrQkFBa0I7a0JBTDlCLFFBQVE7bUJBQUM7b0JBQ1IsU0FBUyxFQUFFLENBQUMsbUJBQW1CLENBQUM7b0JBQ2hDLFlBQVksRUFBRSxDQUFDLHFCQUFxQixDQUFDO29CQUNyQyxPQUFPLEVBQUUsQ0FBQyxxQkFBcUIsQ0FBQztpQkFDakMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgTW9kdWxlV2l0aFByb3ZpZGVycyB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgTnVtZXJpY0ZpZWxkRGlyZWN0aXZlIH0gZnJvbSAnLi9udW1lcmljLWZpZWxkLmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBOdW1iZXJGb3JtYXRTZXJ2aWNlIH0gZnJvbSAnLi9udW1iZXItZm9ybWF0LnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICBwcm92aWRlcnM6IFtOdW1iZXJGb3JtYXRTZXJ2aWNlXSxcbiAgZGVjbGFyYXRpb25zOiBbTnVtZXJpY0ZpZWxkRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW051bWVyaWNGaWVsZERpcmVjdGl2ZV0sXG59KVxuZXhwb3J0IGNsYXNzIE51bWVyaWNGaWVsZE1vZHVsZSB7XG4gIHN0YXRpYyBmb3JSb290KCk6IE1vZHVsZVdpdGhQcm92aWRlcnM8TnVtZXJpY0ZpZWxkTW9kdWxlPiB7XG4gICAgcmV0dXJuIHtcbiAgICAgIG5nTW9kdWxlOiBOdW1lcmljRmllbGRNb2R1bGUsXG4gICAgICBwcm92aWRlcnM6IFtOdW1iZXJGb3JtYXRTZXJ2aWNlXSxcbiAgICB9O1xuICB9XG59XG4iXX0=