@energycap/components 0.31.5 → 0.32.0

package/esm2020/lib/controls/navigation/nav-item-active.directive.mjs

@@ -0,0 +1,92 @@
+import { Directive, Input, Output, EventEmitter } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { Subject } from 'rxjs';
+import { takeUntil, filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class NavItemActiveDirective {
+    constructor(router, el, renderer, route) {
+        this.router = router;
+        this.el = el;
+        this.renderer = renderer;
+        this.route = route;
+        this._exact = true;
+        /** Emits when the url becomes active */
+        this.routerLinkActivated = new EventEmitter();
+        /** Subject that emits when component is destroyed to unsubscribe from any subscriptions */
+        this.destroyed = new Subject();
+    }
+    /**
+     * Determines whether the directive will try to make an exact match on the url or not
+     * If false, the directive will add the active class if the first part of the url matches
+     * the active route.
+     * see: https://angular.io/api/router/Router#isactive
+     */
+    set exact(value) {
+        if (value === undefined) {
+            this._exact = true;
+        }
+        else {
+            this._exact = value;
+        }
+        this.update();
+    }
+    /**
+     * The url of the NavItem to check for activeness. Convert the item url into a
+     * UrlTree relative to the ActivatedRoute so router#isActive works even with relative urls.
+     * See Angular's [routerLink](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link.ts#L249)
+     * and [routerLinkActive](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link_active.ts#L139)
+     * for a similiar implementation.
+     */
+    set url(value) {
+        if (value !== null && value !== undefined) {
+            this._url = this.router.createUrlTree([value], { relativeTo: this.route, queryParams: this.queryParams });
+            this.update();
+        }
+    }
+    /** Check if url is active on NavigationEnd events */
+    ngOnInit() {
+        this.router.events.pipe(takeUntil(this.destroyed), filter(e => e instanceof NavigationEnd)).subscribe(() => {
+            this.update();
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.unsubscribe();
+    }
+    /** If url is active apply the defined class to the element, otherwise remove it */
+    update() {
+        if (this._url && this.classValue) {
+            if (this.router.isActive(this._url, { matrixParams: 'ignored', queryParams: this._exact ? 'exact' : 'subset', paths: this._exact ? 'exact' : 'subset', fragment: 'ignored' })) {
+                this.renderer.addClass(this.el.nativeElement, this.classValue);
+                this.routerLinkActivated.emit(new Event('routerLinkActivated'));
+            }
+            else {
+                this.renderer.removeClass(this.el.nativeElement, this.classValue);
+            }
+        }
+    }
+}
+NavItemActiveDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: NavItemActiveDirective, deps: [{ token: i1.Router }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Directive });
+NavItemActiveDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: NavItemActiveDirective, selector: "[ecNavItemActive]", inputs: { classValue: ["ecNavItemActive", "classValue"], exact: ["ecNavItemActiveExactMatch", "exact"], queryParams: ["ecNavItemActiveQueryParams", "queryParams"], url: ["ecNavItemActiveUrl", "url"] }, outputs: { routerLinkActivated: "routerLinkActivated" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: NavItemActiveDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ecNavItemActive]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.ActivatedRoute }]; }, propDecorators: { classValue: [{
+                type: Input,
+                args: ['ecNavItemActive']
+            }], exact: [{
+                type: Input,
+                args: ['ecNavItemActiveExactMatch']
+            }], queryParams: [{
+                type: Input,
+                args: ['ecNavItemActiveQueryParams']
+            }], url: [{
+                type: Input,
+                args: ['ecNavItemActiveUrl']
+            }], routerLinkActivated: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nav-item-active.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/controls/navigation/nav-item-active.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input, ElementRef, Renderer2, OnInit, OnDestroy, Output, EventEmitter } from '@angular/core';\r\nimport { Router, NavigationEnd, ActivatedRoute, UrlTree, Params } from '@angular/router';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil, filter } from 'rxjs/operators';\r\n\r\n@Directive({\r\n  selector: '[ecNavItemActive]'\r\n})\r\nexport class NavItemActiveDirective implements OnInit, OnDestroy {\r\n\r\n  /** The CSS class to apply to the host element when the url is active */\r\n  @Input('ecNavItemActive') classValue?: string;\r\n\r\n  /**\r\n   * Determines whether the directive will try to make an exact match on the url or not\r\n   * If false, the directive will add the active class if the first part of the url matches\r\n   * the active route.\r\n   * see: https://angular.io/api/router/Router#isactive\r\n   */\r\n  @Input('ecNavItemActiveExactMatch')\r\n  set exact(value: boolean | undefined) {\r\n    if (value === undefined) {\r\n      this._exact = true;\r\n    } else {\r\n      this._exact = value;\r\n    }\r\n    this.update();\r\n  }\r\n  private _exact: boolean = true;\r\n\r\n  /** Router link query params */\r\n  @Input('ecNavItemActiveQueryParams') queryParams?: Params | null;\r\n\r\n  /**\r\n   * The url of the NavItem to check for activeness. Convert the item url into a\r\n   * UrlTree relative to the ActivatedRoute so router#isActive works even with relative urls.\r\n   * See Angular's [routerLink](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link.ts#L249)\r\n   * and [routerLinkActive](https://github.com/angular/angular/blob/8282e15c2becbe42a49befa07d6407247e8243d8/packages/router/src/directives/router_link_active.ts#L139)\r\n   * for a similiar implementation.\r\n   */\r\n  @Input('ecNavItemActiveUrl')\r\n  set url(value: string | undefined) {\r\n    if (value !== null && value !== undefined) {\r\n      this._url = this.router.createUrlTree([value], {relativeTo: this.route, queryParams: this.queryParams});\r\n      this.update();\r\n    }\r\n  }\r\n  private _url?: UrlTree;\r\n\r\n  /** Emits when the url becomes active */\r\n  @Output() routerLinkActivated: EventEmitter<Event> = new EventEmitter();\r\n\r\n  /** Subject that emits when component is destroyed to unsubscribe from any subscriptions */\r\n  private destroyed: Subject<void> = new Subject();\r\n\r\n  constructor(private router: Router, private el: ElementRef, private renderer: Renderer2, private route: ActivatedRoute) {}\r\n\r\n  /** Check if url is active on NavigationEnd events */\r\n  public ngOnInit(): void {\r\n    this.router.events.pipe(\r\n      takeUntil(this.destroyed),\r\n      filter(e => e instanceof NavigationEnd)\r\n    ).subscribe(() => {\r\n      this.update();\r\n    })\r\n  }\r\n\r\n  public ngOnDestroy(): void {\r\n    this.destroyed.next();\r\n    this.destroyed.unsubscribe();\r\n  }\r\n\r\n  /** If url is active apply the defined class to the element, otherwise remove it */\r\n  private update(): void {\r\n    if (this._url && this.classValue) {\r\n      if (this.router.isActive(this._url, { matrixParams: 'ignored', queryParams: this._exact ? 'exact' : 'subset', paths: this._exact ? 'exact' : 'subset', fragment: 'ignored' })) {\r\n        this.renderer.addClass(this.el.nativeElement, this.classValue);\r\n        this.routerLinkActivated.emit(new Event('routerLinkActivated'));\r\n      } else {\r\n        this.renderer.removeClass(this.el.nativeElement, this.classValue);\r\n      }\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/controls/numericbox/numericbox.component.mjs

@@ -0,0 +1,371 @@
+import { Component, ElementRef, Input, ViewChild } from '@angular/core';
+import { UntypedFormControl, Validators } from "@angular/forms";
+import { debounceTime, distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';
+import { getDecimalPattern, integerPattern } from '../../core/validation-patterns';
+import { FormControlBase } from "../form-control-base";
+import { TextboxComponent } from '../textbox/textbox.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/validation-message.service";
+import * as i2 from "../../shared/form-group.helper";
+import * as i3 from "@angular/common";
+import * as i4 from "../textbox/textbox.component";
+import * as i5 from "@ngx-translate/core";
+/**
+ * Custom validator to check that min/max and pattern validation is met on the numericbox
+ * component
+ */
+export const numericboxValidation = (min, max, decimals, maxPrecisionDigits) => {
+    return (control) => {
+        let hasError = false;
+        // If the control is empty we won't attempt to validate, if there is a required
+        // validator we will never get here until there is a value
+        if (control.value && control.value !== "") {
+            let numericPattern;
+            if (decimals && decimals > 0) {
+                numericPattern = getDecimalPattern(decimals);
+            }
+            else if (maxPrecisionDigits) {
+                // Still need to check for a valid number formatting when in max precision mode
+                numericPattern = getDecimalPattern(maxPrecisionDigits);
+            }
+            else {
+                // Allow an optional negative sign and any number of digits 0-9
+                numericPattern = integerPattern;
+            }
+            if (!numericPattern.test(control.value)) {
+                hasError = true;
+            }
+            else if (maxPrecisionDigits) {
+                // Converting to a number then back to string removes trailing zeros, and the regex replace removes
+                // any negative signs, leading zeros or decimal points from the number.
+                const val = Number(control.value).toString().replace(/^-?/, '').replace(/(^0\.)|(\.)/, '');
+                hasError = val.length > maxPrecisionDigits;
+            }
+            // We now know we have a valid number, so we can cast these to numbers
+            // for proper range validation
+            if (min !== undefined && Number(control.value) < min) {
+                hasError = true;
+            }
+            if (max !== undefined && Number(control.value) > max) {
+                hasError = true;
+            }
+        }
+        if (hasError) {
+            return {
+                numericbox: {
+                    valid: false,
+                    min: min,
+                    max: max,
+                    decimals: decimals,
+                    maxPrecisionDigits: maxPrecisionDigits
+                }
+            };
+        }
+        else {
+            return null;
+        }
+    };
+};
+export class NumericboxComponent extends FormControlBase {
+    constructor(validationMessageService, formGroupHelper, renderer) {
+        super(validationMessageService, formGroupHelper);
+        this.validationMessageService = validationMessageService;
+        this.formGroupHelper = formGroupHelper;
+        this.renderer = renderer;
+        /**
+         * Show trailing zeros after the decimal point.
+         * Do not use with maxPrecisionDigits.
+         */
+        this.showPrecision = false;
+        /**
+         * If set to true this will update the form model after a debounce as the user
+         * interacts with the component
+         */
+        this.autoUpdateFormModel = false;
+        /** Flag to tell the page we finally computed a greater than zero
+         *  width for units (if applicable)
+         */
+        this.unitsWidthCalculated = false;
+        /** Flag used to filter the form models value changes subscription
+         *  to prevent the textbox model from being formatted as the form model is updated
+         *  programmatically when the textbox model updates
+         */
+        this.autoUpdatingFormModel = false;
+    }
+    /**
+     * Angular AfterViewInit life-cycle hook
+     * Subscribe to textbox model value changes if the hosting
+     * page has opted in for this component
+     */
+    ngAfterViewInit() {
+        if (this.autoUpdateFormModel) {
+            this.textboxFormModel.valueChanges
+                .pipe(debounceTime(300), distinctUntilChanged(), takeUntil(this.componentDestroyed)).subscribe(() => {
+                this.updateFormModelValue();
+            });
+        }
+    }
+    /**
+     * Angular onChanges life-cycle hook
+     * @see {@link https://angular.io/guide/lifecycle-hooks | Life-cycle hooks}
+     */
+    ngOnChanges(changes) {
+        // If either units change after we've calculated,
+        // reset the flag so we can react and redraw
+        if (changes.rightUnits || changes.leftUnits) {
+            this.unitsWidthCalculated = false;
+        }
+        super.ngOnChanges(changes);
+    }
+    /**
+     * Angular onInit lifecycle hook
+     * If units is defined, set the position and listen for status changes so we
+     * can update the positioning of the units element
+     */
+    ngOnInit() {
+        super.ngOnInit();
+        // Initialize the textbox form model with the value of the form model and synchronize
+        // disabled state
+        this.textboxFormModel = new UntypedFormControl({ value: this.formModel.value, disabled: this.formModel.disabled });
+        // Update the form model's errors when the textbox form model status changes
+        this.textboxFormModel.statusChanges.pipe(takeUntil(this.componentDestroyed)).subscribe(() => {
+            if (this.formModel.enabled) {
+                this.formModel.setErrors(this.textboxFormModel.errors);
+            }
+        });
+        // Synchronize disabled state between form model and internal textbox form model
+        this.formModel.statusChanges.pipe(takeUntil(this.componentDestroyed)).subscribe(() => {
+            if (this.formModel.disabled) {
+                this.textboxFormModel.disable();
+            }
+            else {
+                if (this.textboxFormModel.disabled) {
+                    this.textboxFormModel.enable();
+                }
+            }
+        });
+        // Set textbox validators
+        this.textboxFormModel.setValidators(this.getValidators());
+        // Now that the textbox is set up we will set it's value to whatever the
+        // form model had when we initialized
+        this.textboxFormModel.setValue(this.formatDisplayNumber(this.formModel.value));
+        // If the form model's value changes programmatically we need to update the
+        // textbox form model
+        this.formModel.valueChanges.pipe(
+        // We need to filter out when we are updating it programmatically if the
+        // hosting page has opted into the auto updating input
+        filter(() => !this.autoUpdatingFormModel), takeUntil(this.componentDestroyed)).subscribe(value => {
+            this.textboxFormModel.setValue(this.formatDisplayNumber(value));
+        });
+        // If the textbox status changes we need to update the left units position because
+        // we want to make room for the invalid icon
+        if (this.leftUnits) {
+            this.textboxFormModel.statusChanges.pipe(takeUntil(this.componentDestroyed)).subscribe(() => {
+                this.positionLeftUnits();
+            });
+        }
+    }
+    /**
+     * Angular afterViewChecked lifecycle hook
+     * Show the units element if units is defined. Runs after every ngOnChanges
+     */
+    ngAfterViewChecked() {
+        if ((this.leftUnits || this.rightUnits) && !this.unitsWidthCalculated) {
+            this.showUnits();
+        }
+    }
+    /**
+     * Function that builds and returns a ValidatorFn array to set on the form control
+     */
+    getValidators() {
+        let validators = [];
+        if (this.required) {
+            validators.push(Validators.required);
+        }
+        validators.push(numericboxValidation(this.min, this.max, this.decimals, this.maxPrecisionDigits));
+        return validators;
+    }
+    /**
+     * Focus out event handler for the Textbox component
+     */
+    onFocusOut() {
+        this.updateFormModelValue(true);
+    }
+    /**
+    * Function to set focus on an input programatically after the page
+    * had been rendered.  The highlight text flag will select the text
+    * within the input if passed in and true
+    */
+    setFocus(highlightText) {
+        this.textboxInput.setFocus(highlightText);
+    }
+    /**
+     * When the textbox model updates we need to add some display formatting for
+     * display in the textbox and cast the textbox model to a number. Avoid updating
+     * the form model when the value doesn't change because listeners will fire for no reason
+     */
+    updateFormModelValue(isFocusOut) {
+        if (this.autoUpdateFormModel) {
+            // Make it so value changes on the form model do not get triggered
+            // as we change it programmatically.  We do not want the textbox
+            // model to be updated while the user is in the input
+            this.autoUpdatingFormModel = true;
+        }
+        try {
+            if (this.textboxFormModel.valid || this.textboxFormModel.value === "") {
+                // Start out with null for the number, if the textbox value is not a number
+                // we will clear it out on focus out
+                let number = null;
+                // Make sure the textbox model is a number before trying to update the
+                // form model value with it
+                if (this.textboxFormModel.value && !isNaN(this.textboxFormModel.value)) {
+                    // Our value is a legit number, on focus out we will format it if needed
+                    number = Number(this.textboxFormModel.value);
+                    // Checking if the value has actually changed, if not don't set the
+                    // value to avoid extra listener calls
+                    if (this.formModel.value !== number) {
+                        this.formModel.setValue(number);
+                    }
+                    // The textbox model is not a number, check to see if our form model has a value
+                    // and if so clear it out
+                }
+                else if (this.formModel.value !== null) {
+                    this.formModel.setValue(null);
+                }
+                // We only will update the textbox form model with formatting if needed
+                // on Focus out.  This works well for the user whether the auto update
+                // is opted in or not
+                if (isFocusOut) {
+                    this.textboxFormModel.setValue(this.formatDisplayNumber(number));
+                }
+            }
+            this.formModel.markAsTouched();
+        }
+        catch (error) {
+            // Nothing to display, just ensuring we reset our flag that filters
+            // the form model value changes
+        }
+        finally {
+            this.autoUpdatingFormModel = false;
+        }
+    }
+    /**
+     * Convert a number value to the formmated display string. If there is no value
+     * return null
+     */
+    formatDisplayNumber(value) {
+        if (value || value === 0) {
+            // Guard against calling toFixed if the value isn't a number.  This is possible
+            // if patching a value from outside of the component as you don't have
+            // type checking there
+            if (this.showPrecision && this.decimals && !isNaN(value)) {
+                return value.toFixed(this.decimals);
+            }
+            else {
+                return value.toString();
+            }
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * Position the units element and set the padding in the textbox input based
+     * on the width of the units element
+     */
+    positionRightUnits() {
+        let unitsEl = this.textboxEl.nativeElement.querySelector('.units-right');
+        let inputEl = this.textboxEl.nativeElement.querySelector('input');
+        if (unitsEl && inputEl) {
+            let unitsWidth = unitsEl.offsetWidth;
+            if (unitsWidth > 0) {
+                this.unitsWidthCalculated = true;
+            }
+            let padding = unitsWidth;
+            this.renderer.setStyle(inputEl, 'padding-right', padding + 'px');
+        }
+    }
+    positionLeftUnits() {
+        let unitsEl = this.textboxEl.nativeElement.querySelector('.units-left');
+        let inputEl = this.textboxEl.nativeElement.querySelector('input');
+        if (unitsEl && inputEl) {
+            let unitsWidth = unitsEl.offsetWidth;
+            if (unitsWidth > 0) {
+                this.unitsWidthCalculated = true;
+            }
+            let padding = unitsWidth;
+            let leftPosition = getComputedStyle(unitsEl).left;
+            if (leftPosition) {
+                padding += parseInt(leftPosition.replace('px', ''), 0);
+            }
+            this.renderer.setStyle(inputEl, 'padding-left', padding + 'px');
+        }
+    }
+    /**
+     * Create and append the units element to the textbox element
+     */
+    showUnits() {
+        let inputWrapper = this.textboxEl.nativeElement.querySelector('.input-wrapper');
+        if (inputWrapper) {
+            if (this.leftUnits) {
+                let unitsEl = this.textboxEl.nativeElement.querySelector('.units-left');
+                if (unitsEl) {
+                    this.renderer.setProperty(unitsEl, 'innerHTML', this.leftUnits);
+                }
+                else {
+                    this.renderer.appendChild(inputWrapper, this.makeUnitElement('left', this.leftUnits));
+                }
+                this.positionLeftUnits();
+            }
+            if (this.rightUnits) {
+                let unitsEl = this.textboxEl.nativeElement.querySelector('.units-right');
+                if (unitsEl) {
+                    this.renderer.setProperty(unitsEl, 'innerHTML', this.rightUnits);
+                }
+                else {
+                    this.renderer.appendChild(inputWrapper, this.makeUnitElement('right', this.rightUnits));
+                }
+                this.positionRightUnits();
+            }
+        }
+    }
+    makeUnitElement(side, text) {
+        let unitsEl = this.renderer.createElement('span');
+        this.renderer.setAttribute(unitsEl, 'class', `units units-${side}`);
+        this.renderer.setAttribute(unitsEl, 'id', `${this.id}_units`);
+        this.renderer.setAttribute(unitsEl, 'style', 'pointer-events: none');
+        this.renderer.setProperty(unitsEl, 'innerHTML', text);
+        return unitsEl;
+    }
+}
+NumericboxComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: NumericboxComponent, deps: [{ token: i1.ValidationMessageService }, { token: i2.FormGroupHelper }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+NumericboxComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: NumericboxComponent, selector: "ec-numericbox", inputs: { placeholder: "placeholder", decimals: "decimals", showPrecision: "showPrecision", maxPrecisionDigits: "maxPrecisionDigits", max: "max", min: "min", leftUnits: "leftUnits", rightUnits: "rightUnits", autoUpdateFormModel: "autoUpdateFormModel" }, viewQueries: [{ propertyName: "textboxEl", first: true, predicate: TextboxComponent, descendants: true, read: ElementRef, static: true }, { propertyName: "textboxInput", first: true, predicate: ["textbox"], descendants: true, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div class=\"control control-label-{{labelPosition}}\"\r\n     [class.invalid]=\"formModel?.invalid && (formModel?.touched)\">\r\n  <label *ngIf=\"label\"\r\n         ngPreserveWhitespaces>\r\n    <span>{{label | translate}}</span>\r\n\r\n    <span *ngIf=\"validationErrors.length && formModel?.touched && formModel?.invalid\">{{validationErrors | translate}}</span>\r\n  </label>\r\n  <!-- Setting the maxlength to 13 to combat the user from entering too large of a number\r\n         for javascript to support.  If the user enters all 13 characters as numbers and we have showPrecision set, adding the\r\n         decimal and the empty zero characters will get them in a situation where to edit it they must remove characters\r\n         as we would push them past the limit -->\r\n  <ec-textbox [id]=\"id\"\r\n              #textbox\r\n              class=\"control-input mb-0\"\r\n              [placeholder]=\"placeholder\"\r\n              [maxlength]=\"maxPrecisionDigits ? maxPrecisionDigits + 3 : 13\"\r\n              [autofocus]=\"autofocus\"\r\n              [formModel]=\"textboxFormModel\"\r\n              [required]=\"required\"\r\n              [tabindex]=\"tabindex\"\r\n              [readonly]=\"readonly\"\r\n              [tooltip]=\"tooltip\"\r\n              (focusout)=\"onFocusOut()\">\r\n  </ec-textbox>\r\n</div>\r\n", styles: [":root{--ec-font-size-icon: 1rem;--ec-color-icon: rgba(26, 26, 35, .66)}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(1turn)}}:host{color:var(--ec-color-primary-dark);font-family:var(--ec-font-family);font-size:var(--ec-font-size-body);display:block;margin-bottom:1rem;width:100%}:host :host-context(.form-condensed){margin-bottom:.5rem}:host .control{width:100%;display:flex;flex-direction:column}:host .control.control-label-bottom{flex-direction:column-reverse}:host .control.control-label-left{flex-direction:row}:host .control.control-label-left label{margin-right:.25rem}:host .control.control-label-right{flex-direction:row-reverse}:host .control.control-label-right label{margin-left:.25rem}:host .control.control-label-left,:host .control.control-label-right{align-items:center}:host .control.control-label-left label,:host .control.control-label-right label{flex:1 1;margin-top:0;margin-bottom:0}:host .control.control-label-left .control-input,:host .control.control-label-right .control-input{flex:2 2}:host .control.is-readonly input,:host .control.is-readonly select{border-color:transparent;background-color:#1a1a231f;background-clip:border-box;background-image:none;color:var(--ec-color-primary-dark);opacity:1;-webkit-user-select:none;user-select:none;pointer-events:none;overflow:hidden;white-space:nowrap}:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-invalid,:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-valid{background-color:var(--ec-background-color-caution);background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M20.21 20.21h-8.42L10.95 0h10.1l-.84 20.21zm-8.42 3.37h8.42V32h-8.42z\"/></svg>');background-repeat:no-repeat;background-position:.25rem center;background-size:1rem,1rem;padding-left:1.5rem}:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-invalid:not(:focus),:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-valid:not(:focus){border-color:var(--ec-color-caution)}:host .control.invalid:not(.open) .textbox-group-btn-right ::ng-deep button{background-color:var(--ec-background-color-caution)}:host .control.invalid:not(.open) .textbox-group-btn-right ::ng-deep button:not(:focus){border-color:var(--ec-color-caution)}:host .textbox-group{display:flex;position:relative}:host textarea:focus,:host input:focus,:host select:focus{outline:none}label{color:var(--ec-color-secondary-dark);display:block;font-size:var(--ec-font-size-label);line-height:1;margin:calc(var(--ec-font-size-label) / 2) 0}ec-textbox ::ng-deep .input-wrapper{position:relative}ec-textbox ::ng-deep input{text-align:right}ec-textbox ::ng-deep input:required.is-empty:not(:disabled)~.units-left{left:1.25rem}ec-textbox ::ng-deep input.ng-invalid.ng-touched~.units-left{left:1.25rem}ec-textbox ::ng-deep .control:not(.is-readonly) input:disabled~.units{color:var(--ec-color-secondary-dark);opacity:.65}ec-textbox ::ng-deep .units{height:2rem;line-height:1.25;color:var(--ec-color-primary-dark);font-family:var(--ec-font-family);font-size:var(--ec-font-size-body);display:block;position:absolute;top:1px;padding:.375rem .25rem;z-index:2}ec-textbox ::ng-deep .units.units-right{right:0;padding-right:.5rem}ec-textbox ::ng-deep .units.units-left{left:0;padding-left:.5rem}.control.invalid ec-textbox ::ng-deep input.ng-invalid,.control.invalid ec-textbox ::ng-deep input.ng-valid{background-color:var(--ec-background-color-caution);background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M20.21 20.21h-8.42L10.95 0h10.1l-.84 20.21zm-8.42 3.37h8.42V32h-8.42z\"/></svg>');background-repeat:no-repeat;background-position:.25rem center;background-size:1rem,1rem;padding-left:1.5rem}.control.invalid ec-textbox ::ng-deep input.ng-invalid:not(:focus),.control.invalid ec-textbox ::ng-deep input.ng-valid:not(:focus){border-color:var(--ec-color-caution)}.control.invalid ec-textbox ::ng-deep input.ng-invalid~.units-left,.control.invalid ec-textbox ::ng-deep input.ng-valid~.units-left{left:1.25rem}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.TextboxComponent, selector: "ec-textbox", inputs: ["autocomplete", "type", "placeholder", "maxlength", "minlength", "rows", "selectOnAutofocus", "upperCase"] }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: NumericboxComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-numericbox', template: "<div class=\"control control-label-{{labelPosition}}\"\r\n     [class.invalid]=\"formModel?.invalid && (formModel?.touched)\">\r\n  <label *ngIf=\"label\"\r\n         ngPreserveWhitespaces>\r\n    <span>{{label | translate}}</span>\r\n\r\n    <span *ngIf=\"validationErrors.length && formModel?.touched && formModel?.invalid\">{{validationErrors | translate}}</span>\r\n  </label>\r\n  <!-- Setting the maxlength to 13 to combat the user from entering too large of a number\r\n         for javascript to support.  If the user enters all 13 characters as numbers and we have showPrecision set, adding the\r\n         decimal and the empty zero characters will get them in a situation where to edit it they must remove characters\r\n         as we would push them past the limit -->\r\n  <ec-textbox [id]=\"id\"\r\n              #textbox\r\n              class=\"control-input mb-0\"\r\n              [placeholder]=\"placeholder\"\r\n              [maxlength]=\"maxPrecisionDigits ? maxPrecisionDigits + 3 : 13\"\r\n              [autofocus]=\"autofocus\"\r\n              [formModel]=\"textboxFormModel\"\r\n              [required]=\"required\"\r\n              [tabindex]=\"tabindex\"\r\n              [readonly]=\"readonly\"\r\n              [tooltip]=\"tooltip\"\r\n              (focusout)=\"onFocusOut()\">\r\n  </ec-textbox>\r\n</div>\r\n", styles: [":root{--ec-font-size-icon: 1rem;--ec-color-icon: rgba(26, 26, 35, .66)}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(1turn)}}:host{color:var(--ec-color-primary-dark);font-family:var(--ec-font-family);font-size:var(--ec-font-size-body);display:block;margin-bottom:1rem;width:100%}:host :host-context(.form-condensed){margin-bottom:.5rem}:host .control{width:100%;display:flex;flex-direction:column}:host .control.control-label-bottom{flex-direction:column-reverse}:host .control.control-label-left{flex-direction:row}:host .control.control-label-left label{margin-right:.25rem}:host .control.control-label-right{flex-direction:row-reverse}:host .control.control-label-right label{margin-left:.25rem}:host .control.control-label-left,:host .control.control-label-right{align-items:center}:host .control.control-label-left label,:host .control.control-label-right label{flex:1 1;margin-top:0;margin-bottom:0}:host .control.control-label-left .control-input,:host .control.control-label-right .control-input{flex:2 2}:host .control.is-readonly input,:host .control.is-readonly select{border-color:transparent;background-color:#1a1a231f;background-clip:border-box;background-image:none;color:var(--ec-color-primary-dark);opacity:1;-webkit-user-select:none;user-select:none;pointer-events:none;overflow:hidden;white-space:nowrap}:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-invalid,:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-valid{background-color:var(--ec-background-color-caution);background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M20.21 20.21h-8.42L10.95 0h10.1l-.84 20.21zm-8.42 3.37h8.42V32h-8.42z\"/></svg>');background-repeat:no-repeat;background-position:.25rem center;background-size:1rem,1rem;padding-left:1.5rem}:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-invalid:not(:focus),:host .control.invalid .textbox-group-input ::ng-deep .control input.ng-valid:not(:focus){border-color:var(--ec-color-caution)}:host .control.invalid:not(.open) .textbox-group-btn-right ::ng-deep button{background-color:var(--ec-background-color-caution)}:host .control.invalid:not(.open) .textbox-group-btn-right ::ng-deep button:not(:focus){border-color:var(--ec-color-caution)}:host .textbox-group{display:flex;position:relative}:host textarea:focus,:host input:focus,:host select:focus{outline:none}label{color:var(--ec-color-secondary-dark);display:block;font-size:var(--ec-font-size-label);line-height:1;margin:calc(var(--ec-font-size-label) / 2) 0}ec-textbox ::ng-deep .input-wrapper{position:relative}ec-textbox ::ng-deep input{text-align:right}ec-textbox ::ng-deep input:required.is-empty:not(:disabled)~.units-left{left:1.25rem}ec-textbox ::ng-deep input.ng-invalid.ng-touched~.units-left{left:1.25rem}ec-textbox ::ng-deep .control:not(.is-readonly) input:disabled~.units{color:var(--ec-color-secondary-dark);opacity:.65}ec-textbox ::ng-deep .units{height:2rem;line-height:1.25;color:var(--ec-color-primary-dark);font-family:var(--ec-font-family);font-size:var(--ec-font-size-body);display:block;position:absolute;top:1px;padding:.375rem .25rem;z-index:2}ec-textbox ::ng-deep .units.units-right{right:0;padding-right:.5rem}ec-textbox ::ng-deep .units.units-left{left:0;padding-left:.5rem}.control.invalid ec-textbox ::ng-deep input.ng-invalid,.control.invalid ec-textbox ::ng-deep input.ng-valid{background-color:var(--ec-background-color-caution);background-image:url('data:image/svg+xml;charset=utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 32 32\"><path fill=\"rgba(26, 26, 35, 0.66)\" d=\"M20.21 20.21h-8.42L10.95 0h10.1l-.84 20.21zm-8.42 3.37h8.42V32h-8.42z\"/></svg>');background-repeat:no-repeat;background-position:.25rem center;background-size:1rem,1rem;padding-left:1.5rem}.control.invalid ec-textbox ::ng-deep input.ng-invalid:not(:focus),.control.invalid ec-textbox ::ng-deep input.ng-valid:not(:focus){border-color:var(--ec-color-caution)}.control.invalid ec-textbox ::ng-deep input.ng-invalid~.units-left,.control.invalid ec-textbox ::ng-deep input.ng-valid~.units-left{left:1.25rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ValidationMessageService }, { type: i2.FormGroupHelper }, { type: i0.Renderer2 }]; }, propDecorators: { placeholder: [{
+                type: Input
+            }], decimals: [{
+                type: Input
+            }], showPrecision: [{
+                type: Input
+            }], maxPrecisionDigits: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], leftUnits: [{
+                type: Input
+            }], rightUnits: [{
+                type: Input
+            }], autoUpdateFormModel: [{
+                type: Input
+            }], textboxEl: [{
+                type: ViewChild,
+                args: [TextboxComponent, { read: ElementRef, static: true }]
+            }], textboxInput: [{
+                type: ViewChild,
+                args: ['textbox', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"numericbox.component.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/controls/numericbox/numericbox.component.ts","../../../../../../projects/components/src/lib/controls/numericbox/numericbox.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAmC,SAAS,EAAE,UAAU,EAAE,KAAK,EAA0D,SAAS,EAAE,MAAM,eAAe,CAAC;AACjK,OAAO,EAAmB,kBAAkB,EAAe,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC9F,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEvF,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAEnF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;;;;;;;AAGhE;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,GAAuB,EAAE,GAAuB,EAAE,QAA4B,EAAE,kBAAsC,EAAe,EAAE;IACxK,OAAO,CAAC,OAAwB,EAAE,EAAE;QAChC,IAAI,QAAQ,GAAY,KAAK,CAAC;QAE9B,+EAA+E;QAC/E,0DAA0D;QAC1D,IAAI,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,KAAK,EAAE,EAAE;YAEvC,IAAI,cAAsB,CAAC;YAC3B,IAAI,QAAQ,IAAI,QAAQ,GAAG,CAAC,EAAE;gBAC1B,cAAc,GAAG,iBAAiB,CAAC,QAAQ,CAAC,CAAC;aAChD;iBAAM,IAAI,kBAAkB,EAAE;gBAC3B,+EAA+E;gBAC/E,cAAc,GAAG,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;aAC1D;iBAAM;gBACH,+DAA+D;gBAC/D,cAAc,GAAG,cAAc,CAAC;aACnC;YAED,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;gBACrC,QAAQ,GAAG,IAAI,CAAC;aACnB;iBAAM,IAAI,kBAAkB,EAAE;gBAC3B,mGAAmG;gBACnG,uEAAuE;gBACvE,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC,CAAC;gBAC3F,QAAQ,GAAG,GAAG,CAAC,MAAM,GAAG,kBAAkB,CAAC;aAC9C;YAED,sEAAsE;YACtE,8BAA8B;YAC9B,IAAI,GAAG,KAAK,SAAS,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,EAAE;gBAClD,QAAQ,GAAG,IAAI,CAAC;aACnB;YAED,IAAI,GAAG,KAAK,SAAS,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,GAAG,EAAE;gBAClD,QAAQ,GAAG,IAAI,CAAC;aACnB;SACJ;QAED,IAAI,QAAQ,EAAE;YACV,OAAO;gBACH,UAAU,EAAE;oBACR,KAAK,EAAE,KAAK;oBACZ,GAAG,EAAE,GAAG;oBACR,GAAG,EAAE,GAAG;oBACR,QAAQ,EAAE,QAAQ;oBAClB,kBAAkB,EAAE,kBAAkB;iBACzC;aACJ,CAAC;SACL;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IAEL,CAAC,CAAA;AACL,CAAC,CAAC;AAQF,MAAM,OAAO,mBAAoB,SAAQ,eAAe;IA+FpD,YACc,wBAAkD,EAClD,eAAgC,EAChC,QAAmB;QAE7B,KAAK,CAAC,wBAAwB,EAAE,eAAe,CAAC,CAAC;QAJvC,6BAAwB,GAAxB,wBAAwB,CAA0B;QAClD,oBAAe,GAAf,eAAe,CAAiB;QAChC,aAAQ,GAAR,QAAQ,CAAW;QAnFjC;;;WAGG;QACa,kBAAa,GAAa,KAAK,CAAC;QA2ChD;;;WAGG;QACa,wBAAmB,GAAY,KAAK,CAAC;QAarD;;WAEG;QACK,yBAAoB,GAAY,KAAK,CAAC;QAE9C;;;WAGG;QACK,0BAAqB,GAAY,KAAK,CAAC;IAa/C,CAAC;IAED;;;;OAIG;IACI,eAAe;QAClB,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC1B,IAAI,CAAC,gBAAgB,CAAC,YAAY;iBAC7B,IAAI,CACD,YAAY,CAAC,GAAG,CAAC,EACjB,oBAAoB,EAAE,EACtB,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CACrC,CAAC,SAAS,CAAC,GAAG,EAAE;gBACb,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAChC,CAAC,CAAC,CAAC;SACV;IACL,CAAC;IAED;;;OAGG;IACI,WAAW,CAAC,OAAsB;QACrC,iDAAiD;QACjD,4CAA4C;QAC5C,IAAI,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,SAAS,EAAE;YACzC,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;SACrC;QAED,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAGD;;;;OAIG;IACI,QAAQ;QACX,KAAK,CAAC,QAAQ,EAAE,CAAC;QAEjB,qFAAqF;QACrF,iBAAiB;QACjB,IAAI,CAAC,gBAAgB,GAAG,IAAI,kBAAkB,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC;QAEnH,4EAA4E;QAC5E,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACxF,IAAI,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;gBACxB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;aAC1D;QACL,CAAC,CAAC,CAAA;QAEF,gFAAgF;QAChF,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YACjF,IAAI,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE;gBACzB,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC;aACnC;iBAAM;gBACH,IAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE;oBAChC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC;iBAClC;aACJ;QACL,CAAC,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;QAE1D,wEAAwE;QACxE,qCAAqC;QACrC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;QAE/E,2EAA2E;QAC3E,qBAAqB;QACrB,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI;QAC5B,wEAAwE;QACxE,sDAAsD;QACtD,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,EACzC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YAClD,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;QACpE,CAAC,CAAC,CAAC;QAEP,kFAAkF;QAClF,4CAA4C;QAC5C,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,gBAAgB,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;gBACxF,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC7B,CAAC,CAAC,CAAC;SACN;IACL,CAAC;IAGD;;;OAGG;IACI,kBAAkB;QACrB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE;YACnE,IAAI,CAAC,SAAS,EAAE,CAAC;SACpB;IACL,CAAC;IAED;;OAEG;IACK,aAAa;QACjB,IAAI,UAAU,GAAkB,EAAE,CAAC;QAEnC,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;SACxC;QAED,UAAU,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC;QAElG,OAAO,UAAU,CAAC;IACtB,CAAC;IAED;;OAEG;IACI,UAAU;QACb,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;;;MAIE;IACK,QAAQ,CAAC,aAAuB;QACnC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC9C,CAAC;IAGD;;;;OAIG;IACK,oBAAoB,CAAC,UAAoB;QAC7C,IAAI,IAAI,CAAC,mBAAmB,EAAE;YAC1B,kEAAkE;YAClE,gEAAgE;YAChE,qDAAqD;YACrD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;SACrC;QAED,IAAI;YACA,IAAI,IAAI,CAAC,gBAAgB,CAAC,KAAK,IAAI,IAAI,CAAC,gBAAgB,CAAC,KAAK,KAAK,EAAE,EAAE;gBACnE,2EAA2E;gBAC3E,oCAAoC;gBACpC,IAAI,MAAM,GAAkB,IAAI,CAAC;gBAEjC,sEAAsE;gBACtE,2BAA2B;gBAC3B,IAAI,IAAI,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE;oBACpE,wEAAwE;oBACxE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;oBAE7C,mEAAmE;oBACnE,sCAAsC;oBACtC,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,KAAK,MAAM,EAAE;wBACjC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;qBACnC;oBACD,gFAAgF;oBAChF,yBAAyB;iBAC5B;qBAAM,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK,KAAK,IAAI,EAAE;oBACtC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;iBACjC;gBAED,uEAAuE;gBACvE,sEAAsE;gBACtE,qBAAqB;gBACrB,IAAI,UAAU,EAAE;oBACZ,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;iBACpE;aACJ;YAED,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC;SAClC;QAAC,OAAO,KAAK,EAAE;YACZ,mEAAmE;YACnE,+BAA+B;SAClC;gBAAS;YACN,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;SACtC;IACL,CAAC;IAED;;;OAGG;IACK,mBAAmB,CAAC,KAAgC;QACxD,IAAI,KAAK,IAAI,KAAK,KAAK,CAAC,EAAE;YACtB,+EAA+E;YAC/E,sEAAsE;YACtE,sBAAsB;YACtB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;gBACtD,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aACvC;iBAAM;gBACH,OAAO,KAAK,CAAC,QAAQ,EAAE,CAAC;aAC3B;SACJ;aAAM;YACH,OAAO,IAAI,CAAC;SACf;IACL,CAAC;IAED;;;OAGG;IACK,kBAAkB;QACtB,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QACzE,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAElE,IAAI,OAAO,IAAI,OAAO,EAAE;YACpB,IAAI,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;YAErC,IAAI,UAAU,GAAG,CAAC,EAAE;gBAChB,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;aACpC;YAED,IAAI,OAAO,GAAG,UAAU,CAAC;YACzB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC,CAAC;SACpE;IACL,CAAC;IAGO,iBAAiB;QACrB,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;QACxE,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAElE,IAAI,OAAO,IAAI,OAAO,EAAE;YACpB,IAAI,UAAU,GAAG,OAAO,CAAC,WAAW,CAAC;YAErC,IAAI,UAAU,GAAG,CAAC,EAAE;gBAChB,IAAI,CAAC,oBAAoB,GAAG,IAAI,CAAC;aACpC;YAED,IAAI,OAAO,GAAG,UAAU,CAAC;YACzB,IAAI,YAAY,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC;YAClD,IAAI,YAAY,EAAE;gBACd,OAAO,IAAI,QAAQ,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;aAC1D;YACD,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI,CAAC,CAAC;SACnE;IACL,CAAC;IAED;;OAEG;IACK,SAAS;QACb,IAAI,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC;QAEhF,IAAI,YAAY,EAAE;YACd,IAAI,IAAI,CAAC,SAAS,EAAE;gBAChB,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;gBACxE,IAAI,OAAO,EAAE;oBACT,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;iBACnE;qBAAM;oBACH,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;iBACzF;gBACD,IAAI,CAAC,iBAAiB,EAAE,CAAC;aAC5B;YAED,IAAI,IAAI,CAAC,UAAU,EAAE;gBACjB,IAAI,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;gBACzE,IAAI,OAAO,EAAE;oBACT,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;iBACpE;qBAAM;oBACH,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,YAAY,EAAE,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;iBAC3F;gBACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;aAC7B;SACJ;IACL,CAAC;IAEO,eAAe,CAAC,IAAsB,EAAE,IAAY;QACxD,IAAI,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,eAAe,IAAI,EAAE,CAAC,CAAC;QACpE,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAC;QAC9D,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,sBAAsB,CAAC,CAAC;QACrE,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;QAEtD,OAAO,OAAO,CAAC;IACnB,CAAC;;gHAjYQ,mBAAmB;oGAAnB,mBAAmB,8VAuEjB,gBAAgB,2BAAU,UAAU,+LCnJnD,k0CA0BA;2FDkDa,mBAAmB;kBAN/B,SAAS;+BACI,eAAe;qKAWT,WAAW;sBAA1B,KAAK;gBAMU,QAAQ;sBAAvB,KAAK;gBAOU,aAAa;sBAA5B,KAAK;gBASU,kBAAkB;sBAAjC,KAAK;gBAUU,GAAG;sBAAlB,KAAK;gBAUU,GAAG;sBAAlB,KAAK;gBAMU,SAAS;sBAAxB,KAAK;gBAMU,UAAU;sBAAzB,KAAK;gBAMU,mBAAmB;sBAAlC,KAAK;gBAKmE,SAAS;sBAAjF,SAAS;uBAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE;gBAsBf,YAAY;sBAA3D,SAAS;uBAAC,SAAS,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import { AfterViewChecked, AfterViewInit, Component, ElementRef, Input, OnChanges, OnDestroy, OnInit, Renderer2, SimpleChanges, ViewChild } from '@angular/core';\r\nimport { AbstractControl, UntypedFormControl, ValidatorFn, Validators } from \"@angular/forms\";\r\nimport { debounceTime, distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';\r\nimport { ValidationMessageService } from '../../core/validation-message.service';\r\nimport { getDecimalPattern, integerPattern } from '../../core/validation-patterns';\r\nimport { FormGroupHelper } from '../../shared/form-group.helper';\r\nimport { FormControlBase } from \"../form-control-base\";\r\nimport { TextboxComponent } from '../textbox/textbox.component';\r\n\r\n\r\n/**\r\n * Custom validator to check that min/max and pattern validation is met on the numericbox\r\n * component\r\n */\r\nexport const numericboxValidation = (min: number | undefined, max: number | undefined, decimals: number | undefined, maxPrecisionDigits: number | undefined): ValidatorFn => {\r\n    return (control: AbstractControl) => {\r\n        let hasError: boolean = false;\r\n\r\n        // If the control is empty we won't attempt to validate, if there is a required\r\n        // validator we will never get here until there is a value\r\n        if (control.value && control.value !== \"\") {\r\n\r\n            let numericPattern: RegExp;\r\n            if (decimals && decimals > 0) {\r\n                numericPattern = getDecimalPattern(decimals);\r\n            } else if (maxPrecisionDigits) {\r\n                // Still need to check for a valid number formatting when in max precision mode\r\n                numericPattern = getDecimalPattern(maxPrecisionDigits);\r\n            } else {\r\n                // Allow an optional negative sign and any number of digits 0-9\r\n                numericPattern = integerPattern;\r\n            }\r\n\r\n            if (!numericPattern.test(control.value)) {\r\n                hasError = true;\r\n            } else if (maxPrecisionDigits) {\r\n                // Converting to a number then back to string removes trailing zeros, and the regex replace removes\r\n                // any negative signs, leading zeros or decimal points from the number.\r\n                const val = Number(control.value).toString().replace(/^-?/, '').replace(/(^0\\.)|(\\.)/, '');\r\n                hasError = val.length > maxPrecisionDigits;\r\n            }\r\n\r\n            // We now know we have a valid number, so we can cast these to numbers\r\n            // for proper range validation\r\n            if (min !== undefined && Number(control.value) < min) {\r\n                hasError = true;\r\n            }\r\n\r\n            if (max !== undefined && Number(control.value) > max) {\r\n                hasError = true;\r\n            }\r\n        }\r\n\r\n        if (hasError) {\r\n            return {\r\n                numericbox: {\r\n                    valid: false,\r\n                    min: min,\r\n                    max: max,\r\n                    decimals: decimals,\r\n                    maxPrecisionDigits: maxPrecisionDigits\r\n                }\r\n            };\r\n        } else {\r\n            return null;\r\n        }\r\n\r\n    }\r\n};\r\n\r\n@Component({\r\n    selector: 'ec-numericbox',\r\n    templateUrl: './numericbox.component.html',\r\n    styleUrls: ['./numericbox.component.scss']\r\n})\r\n\r\nexport class NumericboxComponent extends FormControlBase implements OnInit, OnDestroy, OnChanges, AfterViewChecked, AfterViewInit {\r\n\r\n\r\n    /**\r\n     * The value of the textbox input's placeholder\r\n     */\r\n    @Input() public placeholder?: string;\r\n\r\n    /**\r\n     * The number of decimals allowed.  If not supplied the input value will be validated as a\r\n     * whole number\r\n     */\r\n    @Input() public decimals?: number;\r\n\r\n\r\n    /**\r\n     * Show trailing zeros after the decimal point.\r\n     * Do not use with maxPrecisionDigits.\r\n     */\r\n    @Input() public showPrecision?: boolean = false;\r\n\r\n\r\n    /**\r\n     * The maximum total digits a number can have left or right of the decimal point.\r\n     * Due to limitations with how JS handles numbers, the max value for this is 15.\r\n     * Numbers longer than 15 digits may cause rounding errors.\r\n     * Do not use with showPrecision = true\r\n     */\r\n    @Input() public maxPrecisionDigits?: number;\r\n\r\n\r\n    /**\r\n     * The maximum value allowed in the input\r\n     *\r\n     * This is for adding the attribute on the element to get the browser functionality\r\n     * from the input.  If you need the form to be validated before submission, apply the\r\n     * max validator to the form conrol.\r\n     */\r\n    @Input() public max?: number;\r\n\r\n\r\n    /**\r\n     * The minimum value allowed in the input\r\n     *\r\n     * This is for adding the attribute on the element to get the browser functionality\r\n     * from the input.  If you need the form to be validated before submission, apply the\r\n     * min validator to the form conrol.\r\n     */\r\n    @Input() public min?: number;\r\n\r\n\r\n    /**\r\n     * Text to display on the left side of the input\r\n     */\r\n    @Input() public leftUnits?: string;\r\n\r\n\r\n    /**\r\n     * Text to display on the right side of the input\r\n     */\r\n    @Input() public rightUnits?: string;\r\n\r\n    /**\r\n     * If set to true this will update the form model after a debounce as the user\r\n     * interacts with the component\r\n     */\r\n    @Input() public autoUpdateFormModel: boolean = false;\r\n\r\n    /**\r\n     * A reference to the textbox element\r\n     */\r\n    @ViewChild(TextboxComponent, { read: ElementRef, static: true }) private textboxEl!: ElementRef;\r\n\r\n\r\n    /**\r\n     * The internal form model we use to display the value with formatting\r\n     */\r\n    public textboxFormModel!: UntypedFormControl;\r\n\r\n    /** Flag to tell the page we finally computed a greater than zero\r\n     *  width for units (if applicable)\r\n     */\r\n    private unitsWidthCalculated: boolean = false;\r\n\r\n    /** Flag used to filter the form models value changes subscription\r\n     *  to prevent the textbox model from being formatted as the form model is updated\r\n     *  programmatically when the textbox model updates\r\n     */\r\n    private autoUpdatingFormModel: boolean = false;\r\n\r\n    /**\r\n   * Reference to the textbox input control\r\n   */\r\n    @ViewChild('textbox', { static: true }) private textboxInput!: TextboxComponent;\r\n\r\n    constructor(\r\n        protected validationMessageService: ValidationMessageService,\r\n        protected formGroupHelper: FormGroupHelper,\r\n        protected renderer: Renderer2\r\n    ) {\r\n        super(validationMessageService, formGroupHelper);\r\n    }\r\n\r\n    /**\r\n     * Angular AfterViewInit life-cycle hook\r\n     * Subscribe to textbox model value changes if the hosting\r\n     * page has opted in for this component\r\n     */\r\n    public ngAfterViewInit(): void {\r\n        if (this.autoUpdateFormModel) {\r\n            this.textboxFormModel.valueChanges\r\n                .pipe(\r\n                    debounceTime(300),\r\n                    distinctUntilChanged(),\r\n                    takeUntil(this.componentDestroyed),\r\n                ).subscribe(() => {\r\n                    this.updateFormModelValue();\r\n                });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Angular onChanges life-cycle hook\r\n     * @see {@link https://angular.io/guide/lifecycle-hooks | Life-cycle hooks}\r\n     */\r\n    public ngOnChanges(changes: SimpleChanges): void {\r\n        // If either units change after we've calculated,\r\n        // reset the flag so we can react and redraw\r\n        if (changes.rightUnits || changes.leftUnits) {\r\n            this.unitsWidthCalculated = false;\r\n        }\r\n\r\n        super.ngOnChanges(changes);\r\n    }\r\n\r\n\r\n    /**\r\n     * Angular onInit lifecycle hook\r\n     * If units is defined, set the position and listen for status changes so we\r\n     * can update the positioning of the units element\r\n     */\r\n    public ngOnInit(): void {\r\n        super.ngOnInit();\r\n\r\n        // Initialize the textbox form model with the value of the form model and synchronize\r\n        // disabled state\r\n        this.textboxFormModel = new UntypedFormControl({ value: this.formModel.value, disabled: this.formModel.disabled });\r\n\r\n        // Update the form model's errors when the textbox form model status changes\r\n        this.textboxFormModel.statusChanges.pipe(takeUntil(this.componentDestroyed)).subscribe(() => {\r\n            if (this.formModel.enabled) {\r\n                this.formModel.setErrors(this.textboxFormModel.errors);\r\n            }\r\n        })\r\n\r\n        // Synchronize disabled state between form model and internal textbox form model\r\n        this.formModel.statusChanges.pipe(takeUntil(this.componentDestroyed)).subscribe(() => {\r\n            if (this.formModel.disabled) {\r\n                this.textboxFormModel.disable();\r\n            } else {\r\n                if (this.textboxFormModel.disabled) {\r\n                    this.textboxFormModel.enable();\r\n                }\r\n            }\r\n        });\r\n\r\n        // Set textbox validators\r\n        this.textboxFormModel.setValidators(this.getValidators());\r\n\r\n        // Now that the textbox is set up we will set it's value to whatever the\r\n        // form model had when we initialized\r\n        this.textboxFormModel.setValue(this.formatDisplayNumber(this.formModel.value));\r\n\r\n        // If the form model's value changes programmatically we need to update the\r\n        // textbox form model\r\n        this.formModel.valueChanges.pipe(\r\n            // We need to filter out when we are updating it programmatically if the\r\n            // hosting page has opted into the auto updating input\r\n            filter(() => !this.autoUpdatingFormModel),\r\n            takeUntil(this.componentDestroyed)).subscribe(value => {\r\n                this.textboxFormModel.setValue(this.formatDisplayNumber(value));\r\n            });\r\n\r\n        // If the textbox status changes we need to update the left units position because\r\n        // we want to make room for the invalid icon\r\n        if (this.leftUnits) {\r\n            this.textboxFormModel.statusChanges.pipe(takeUntil(this.componentDestroyed)).subscribe(() => {\r\n                this.positionLeftUnits();\r\n            });\r\n        }\r\n    }\r\n\r\n\r\n    /**\r\n     * Angular afterViewChecked lifecycle hook\r\n     * Show the units element if units is defined. Runs after every ngOnChanges\r\n     */\r\n    public ngAfterViewChecked(): void {\r\n        if ((this.leftUnits || this.rightUnits) && !this.unitsWidthCalculated) {\r\n            this.showUnits();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Function that builds and returns a ValidatorFn array to set on the form control\r\n     */\r\n    private getValidators(): ValidatorFn[] {\r\n        let validators: ValidatorFn[] = [];\r\n\r\n        if (this.required) {\r\n            validators.push(Validators.required);\r\n        }\r\n\r\n        validators.push(numericboxValidation(this.min, this.max, this.decimals, this.maxPrecisionDigits));\r\n\r\n        return validators;\r\n    }\r\n\r\n    /**\r\n     * Focus out event handler for the Textbox component\r\n     */\r\n    public onFocusOut(): void {\r\n        this.updateFormModelValue(true);\r\n    }\r\n\r\n    /**\r\n    * Function to set focus on an input programatically after the page\r\n    * had been rendered.  The highlight text flag will select the text\r\n    * within the input if passed in and true\r\n    */\r\n    public setFocus(highlightText?: boolean): void {\r\n        this.textboxInput.setFocus(highlightText);\r\n    }\r\n\r\n\r\n    /**\r\n     * When the textbox model updates we need to add some display formatting for\r\n     * display in the textbox and cast the textbox model to a number. Avoid updating\r\n     * the form model when the value doesn't change because listeners will fire for no reason\r\n     */\r\n    private updateFormModelValue(isFocusOut?: boolean): void {\r\n        if (this.autoUpdateFormModel) {\r\n            // Make it so value changes on the form model do not get triggered\r\n            // as we change it programmatically.  We do not want the textbox\r\n            // model to be updated while the user is in the input\r\n            this.autoUpdatingFormModel = true;\r\n        }\r\n\r\n        try {\r\n            if (this.textboxFormModel.valid || this.textboxFormModel.value === \"\") {\r\n                // Start out with null for the number, if the textbox value is not a number\r\n                // we will clear it out on focus out\r\n                let number: number | null = null;\r\n\r\n                // Make sure the textbox model is a number before trying to update the\r\n                // form model value with it\r\n                if (this.textboxFormModel.value && !isNaN(this.textboxFormModel.value)) {\r\n                    // Our value is a legit number, on focus out we will format it if needed\r\n                    number = Number(this.textboxFormModel.value);\r\n\r\n                    // Checking if the value has actually changed, if not don't set the\r\n                    // value to avoid extra listener calls\r\n                    if (this.formModel.value !== number) {\r\n                        this.formModel.setValue(number);\r\n                    }\r\n                    // The textbox model is not a number, check to see if our form model has a value\r\n                    // and if so clear it out\r\n                } else if (this.formModel.value !== null) {\r\n                    this.formModel.setValue(null);\r\n                }\r\n\r\n                // We only will update the textbox form model with formatting if needed\r\n                // on Focus out.  This works well for the user whether the auto update\r\n                // is opted in or not\r\n                if (isFocusOut) {\r\n                    this.textboxFormModel.setValue(this.formatDisplayNumber(number));\r\n                }\r\n            }\r\n\r\n            this.formModel.markAsTouched();\r\n        } catch (error) {\r\n            // Nothing to display, just ensuring we reset our flag that filters\r\n            // the form model value changes\r\n        } finally {\r\n            this.autoUpdatingFormModel = false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Convert a number value to the formmated display string. If there is no value\r\n     * return null\r\n     */\r\n    private formatDisplayNumber(value: number | null | undefined): string | null {\r\n        if (value || value === 0) {\r\n            // Guard against calling toFixed if the value isn't a number.  This is possible\r\n            // if patching a value from outside of the component as you don't have\r\n            // type checking there\r\n            if (this.showPrecision && this.decimals && !isNaN(value)) {\r\n                return value.toFixed(this.decimals);\r\n            } else {\r\n                return value.toString();\r\n            }\r\n        } else {\r\n            return null;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Position the units element and set the padding in the textbox input based\r\n     * on the width of the units element\r\n     */\r\n    private positionRightUnits(): void {\r\n        let unitsEl = this.textboxEl.nativeElement.querySelector('.units-right');\r\n        let inputEl = this.textboxEl.nativeElement.querySelector('input');\r\n\r\n        if (unitsEl && inputEl) {\r\n            let unitsWidth = unitsEl.offsetWidth;\r\n\r\n            if (unitsWidth > 0) {\r\n                this.unitsWidthCalculated = true;\r\n            }\r\n\r\n            let padding = unitsWidth;\r\n            this.renderer.setStyle(inputEl, 'padding-right', padding + 'px');\r\n        }\r\n    }\r\n\r\n\r\n    private positionLeftUnits() {\r\n        let unitsEl = this.textboxEl.nativeElement.querySelector('.units-left');\r\n        let inputEl = this.textboxEl.nativeElement.querySelector('input');\r\n\r\n        if (unitsEl && inputEl) {\r\n            let unitsWidth = unitsEl.offsetWidth;\r\n\r\n            if (unitsWidth > 0) {\r\n                this.unitsWidthCalculated = true;\r\n            }\r\n\r\n            let padding = unitsWidth;\r\n            let leftPosition = getComputedStyle(unitsEl).left;\r\n            if (leftPosition) {\r\n                padding += parseInt(leftPosition.replace('px', ''), 0);\r\n            }\r\n            this.renderer.setStyle(inputEl, 'padding-left', padding + 'px');\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Create and append the units element to the textbox element\r\n     */\r\n    private showUnits(): void {\r\n        let inputWrapper = this.textboxEl.nativeElement.querySelector('.input-wrapper');\r\n\r\n        if (inputWrapper) {\r\n            if (this.leftUnits) {\r\n                let unitsEl = this.textboxEl.nativeElement.querySelector('.units-left');\r\n                if (unitsEl) {\r\n                    this.renderer.setProperty(unitsEl, 'innerHTML', this.leftUnits);\r\n                } else {\r\n                    this.renderer.appendChild(inputWrapper, this.makeUnitElement('left', this.leftUnits));\r\n                }\r\n                this.positionLeftUnits();\r\n            }\r\n\r\n            if (this.rightUnits) {\r\n                let unitsEl = this.textboxEl.nativeElement.querySelector('.units-right');\r\n                if (unitsEl) {\r\n                    this.renderer.setProperty(unitsEl, 'innerHTML', this.rightUnits);\r\n                } else {\r\n                    this.renderer.appendChild(inputWrapper, this.makeUnitElement('right', this.rightUnits));\r\n                }\r\n                this.positionRightUnits();\r\n            }\r\n        }\r\n    }\r\n\r\n    private makeUnitElement(side: 'left' | 'right', text: string): any {\r\n        let unitsEl = this.renderer.createElement('span');\r\n        this.renderer.setAttribute(unitsEl, 'class', `units units-${side}`);\r\n        this.renderer.setAttribute(unitsEl, 'id', `${this.id}_units`);\r\n        this.renderer.setAttribute(unitsEl, 'style', 'pointer-events: none');\r\n        this.renderer.setProperty(unitsEl, 'innerHTML', text);\r\n\r\n        return unitsEl;\r\n    }\r\n}","<div class=\"control control-label-{{labelPosition}}\"\r\n     [class.invalid]=\"formModel?.invalid && (formModel?.touched)\">\r\n  <label *ngIf=\"label\"\r\n         ngPreserveWhitespaces>\r\n    <span>{{label | translate}}</span>\r\n\r\n    <span *ngIf=\"validationErrors.length && formModel?.touched && formModel?.invalid\">{{validationErrors | translate}}</span>\r\n  </label>\r\n  <!-- Setting the maxlength to 13 to combat the user from entering too large of a number\r\n         for javascript to support.  If the user enters all 13 characters as numbers and we have showPrecision set, adding the\r\n         decimal and the empty zero characters will get them in a situation where to edit it they must remove characters\r\n         as we would push them past the limit -->\r\n  <ec-textbox [id]=\"id\"\r\n              #textbox\r\n              class=\"control-input mb-0\"\r\n              [placeholder]=\"placeholder\"\r\n              [maxlength]=\"maxPrecisionDigits ? maxPrecisionDigits + 3 : 13\"\r\n              [autofocus]=\"autofocus\"\r\n              [formModel]=\"textboxFormModel\"\r\n              [required]=\"required\"\r\n              [tabindex]=\"tabindex\"\r\n              [readonly]=\"readonly\"\r\n              [tooltip]=\"tooltip\"\r\n              (focusout)=\"onFocusOut()\">\r\n  </ec-textbox>\r\n</div>\r\n"]}