@ptsecurity/mosaic 15.5.0 → 16.0.0

package/esm2022/input/input-number.mjs

@@ -0,0 +1,168 @@
+import { Attribute, Directive, ElementRef, Input, Optional, Self } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { END, C, V, X, A, Z, DELETE, BACKSPACE, TAB, ENTER, ESCAPE, ZERO, NINE, NUMPAD_ZERO, NUMPAD_NINE, NUMPAD_MINUS, DASH, FF_MINUS, LEFT_ARROW, RIGHT_ARROW, HOME, UP_ARROW, DOWN_ARROW, F1, F12 } from '@ptsecurity/cdk/keycodes';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export const BIG_STEP = 10;
+export const SMALL_STEP = 1;
+export function normalizeSplitter(value) {
+    return value ? value.replace(/,/g, '.') : value;
+}
+export function isFloat(value) {
+    return /^-?\d+\.\d+$/.test(value);
+}
+export function isInt(value) {
+    return /^-?\d+$/.test(value);
+}
+export function isDigit(value) {
+    return isFloat(value) || isInt(value);
+}
+export function getPrecision(value) {
+    const arr = value.toString().split('.');
+    return arr.length === 1
+        ? 1
+        // tslint:disable-next-line:no-magic-numbers
+        : Math.pow(10, arr[1].length);
+}
+export function add(value1, value2) {
+    const precision = Math.max(getPrecision(value1), getPrecision(value2));
+    return (value1 * precision + value2 * precision) / precision;
+}
+export class McNumberInput {
+    get nativeElement() {
+        return this.elementRef.nativeElement;
+    }
+    constructor(elementRef, ngControl, step, bigStep, min, max) {
+        this.elementRef = elementRef;
+        this.ngControl = ngControl;
+        this.focused = false;
+        this.stateChanges = new Subject();
+        this.step = isDigit(step) ? parseFloat(step) : SMALL_STEP;
+        this.bigStep = isDigit(bigStep) ? parseFloat(bigStep) : BIG_STEP;
+        this.min = isDigit(min) ? parseFloat(min) : -Infinity;
+        this.max = isDigit(max) ? parseFloat(max) : Infinity;
+        if ('valueAsNumber' in this.nativeElement) {
+            Object.defineProperty(Object.getPrototypeOf(this.nativeElement), 'valueAsNumber', {
+                // tslint:disable-next-line:no-reserved-keywords
+                get() {
+                    const res = parseFloat(normalizeSplitter(this.value));
+                    return isNaN(res) ? null : res;
+                }
+            });
+        }
+    }
+    focusChanged(isFocused) {
+        if (isFocused !== this.focused) {
+            this.focused = isFocused;
+            this.stateChanges.next();
+        }
+    }
+    onKeyDown(event) {
+        // tslint:disable-next-line:deprecation
+        const keyCode = event.keyCode;
+        const isCtrlA = (e) => e.keyCode === A && (e.ctrlKey || e.metaKey);
+        const isCtrlC = (e) => e.keyCode === C && (e.ctrlKey || e.metaKey);
+        const isCtrlV = (e) => e.keyCode === V && (e.ctrlKey || e.metaKey);
+        const isCtrlX = (e) => e.keyCode === X && (e.ctrlKey || e.metaKey);
+        const isCtrlZ = (e) => e.keyCode === Z && (e.ctrlKey || e.metaKey);
+        const isFKey = (e) => e.keyCode >= F1 && e.keyCode <= F12;
+        const isNumber = (e) => (e.keyCode >= ZERO && e.keyCode <= NINE) ||
+            (e.keyCode >= NUMPAD_ZERO && e.keyCode <= NUMPAD_NINE);
+        const isPeriod = (e) => e.key === '.' || e.key === ',';
+        const minuses = [NUMPAD_MINUS, DASH, FF_MINUS];
+        const serviceKeys = [DELETE, BACKSPACE, TAB, ESCAPE, ENTER];
+        const arrows = [LEFT_ARROW, RIGHT_ARROW];
+        const allowedKeys = [HOME, END].concat(arrows).concat(serviceKeys).concat(minuses);
+        if (minuses.includes(keyCode) &&
+            (this.nativeElement.valueAsNumber || this.min >= 0 || this.nativeElement.validity?.badInput)) {
+            event.preventDefault();
+            return;
+        }
+        if (allowedKeys.indexOf(keyCode) !== -1 ||
+            isCtrlA(event) ||
+            isCtrlC(event) ||
+            isCtrlV(event) ||
+            isCtrlX(event) ||
+            isCtrlZ(event) ||
+            isFKey(event) ||
+            isPeriod(event)) {
+            // let it happen, don't do anything
+            return;
+        }
+        // Ensure that it is not a number and stop the keypress
+        if (event.shiftKey || !isNumber(event)) {
+            event.preventDefault();
+            // process steps
+            const step = event.shiftKey ? this.bigStep : this.step;
+            if (keyCode === UP_ARROW) {
+                this.stepUp(step);
+            }
+            if (keyCode === DOWN_ARROW) {
+                this.stepDown(step);
+            }
+        }
+    }
+    onPaste(event) {
+        if (!isDigit(normalizeSplitter(event.clipboardData.getData('text')))) {
+            event.preventDefault();
+        }
+    }
+    stepUp(step) {
+        this.elementRef.nativeElement.focus();
+        const res = Math.max(Math.min(add(this.nativeElement.valueAsNumber || 0, step), this.max), this.min);
+        this.nativeElement.value = res.toString();
+        this.viewToModelUpdate(this.nativeElement.valueAsNumber);
+    }
+    stepDown(step) {
+        this.elementRef.nativeElement.focus();
+        const res = Math.min(Math.max(add(this.nativeElement.valueAsNumber || 0, -step), this.min), this.max);
+        this.nativeElement.value = res.toString();
+        this.viewToModelUpdate(this.nativeElement.valueAsNumber);
+    }
+    viewToModelUpdate(value) {
+        if (this.ngControl) {
+            this.ngControl.control.setValue(value);
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McNumberInput, deps: [{ token: i0.ElementRef }, { token: i1.NgControl, optional: true, self: true }, { token: 'step', attribute: true }, { token: 'big-step', attribute: true }, { token: 'min', attribute: true }, { token: 'max', attribute: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: McNumberInput, selector: "input[mcInput][type=\"number\"]", inputs: { bigStep: "bigStep", step: "step", min: "min", max: "max" }, host: { listeners: { "blur": "focusChanged(false)", "focus": "focusChanged(true)", "paste": "onPaste($event)", "keydown": "onKeyDown($event)" } }, exportAs: ["mcNumericalInput"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McNumberInput, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `input[mcInput][type="number"]`,
+                    exportAs: 'mcNumericalInput',
+                    host: {
+                        '(blur)': 'focusChanged(false)',
+                        '(focus)': 'focusChanged(true)',
+                        '(paste)': 'onPaste($event)',
+                        '(keydown)': 'onKeyDown($event)'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['step']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['big-step']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['min']
+                }] }, { type: undefined, decorators: [{
+                    type: Attribute,
+                    args: ['max']
+                }] }]; }, propDecorators: { bigStep: [{
+                type: Input
+            }], step: [{
+                type: Input
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-number.js","sourceRoot":"","sources":["../../../../packages/mosaic/input/input-number.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,EACT,SAAS,EACT,UAAU,EACV,KAAK,EACL,QAAQ,EACR,IAAI,EACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EACH,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EACjD,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,IAAI,EAChE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE,GAAG,EACzE,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;;;AAG/B,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC;AAC3B,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,CAAC;AAE5B,MAAM,UAAU,iBAAiB,CAAC,KAAa;IAC3C,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AACpD,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,KAAa;IACjC,OAAO,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,KAAa;IAC/B,OAAO,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,OAAO,CAAC,KAAa;IACjC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAExC,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC;QACnB,CAAC,CAAC,CAAC;QACH,4CAA4C;QAC5C,CAAC,CAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,GAAG,CAAC,MAAc,EAAE,MAAc;IAC9C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvE,OAAO,CAAC,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;AACjE,CAAC;AAaD,MAAM,OAAO,aAAa;IAmBtB,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;IACzC,CAAC;IAED,YACY,UAAsB,EACF,SAAoB,EAC7B,IAAY,EACR,OAAe,EACpB,GAAW,EACX,GAAW;QALrB,eAAU,GAAV,UAAU,CAAY;QACF,cAAS,GAAT,SAAS,CAAW;QAVpD,YAAO,GAAY,KAAK,CAAC;QAEhB,iBAAY,GAAkB,IAAI,OAAO,EAAQ,CAAC;QAcvD,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;QAC1D,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACjE,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QACtD,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;QAErD,IAAI,eAAe,IAAI,IAAI,CAAC,aAAa,EAAE;YACvC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE,eAAe,EAAE;gBAC9E,gDAAgD;gBAChD,GAAG;oBACC,MAAM,GAAG,GAAG,UAAU,CAAC,iBAAiB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;oBAEtD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC;gBACnC,CAAC;aACJ,CAAC,CAAC;SACN;IACL,CAAC;IAED,YAAY,CAAC,SAAkB;QAC3B,IAAI,SAAS,KAAK,IAAI,CAAC,OAAO,EAAE;YAC5B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC5B;IACL,CAAC;IAED,SAAS,CAAC,KAAoB;QAC1B,uCAAuC;QACvC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAE9B,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;QACnE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;QACnE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;QACnE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;QACnE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC;QAEnE,MAAM,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,EAAE,IAAI,CAAC,CAAC,OAAO,IAAI,GAAG,CAAC;QAE1D,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,IAAI,IAAI,IAAI,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC;YAC5D,CAAC,CAAC,CAAC,OAAO,IAAI,WAAW,IAAI,CAAC,CAAC,OAAO,IAAI,WAAW,CAAC,CAAC;QAE3D,MAAM,QAAQ,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC;QAEvD,MAAM,OAAO,GAAG,CAAC,YAAY,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC;QAC/C,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;QACzC,MAAM,WAAW,GAAI,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAEpF,IACI,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC;YACzB,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,IAAI,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAC9F;YACE,KAAK,CAAC,cAAc,EAAE,CAAC;YAEvB,OAAO;SACV;QAED,IAAI,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YACnC,OAAO,CAAC,KAAK,CAAC;YACd,OAAO,CAAC,KAAK,CAAC;YACd,OAAO,CAAC,KAAK,CAAC;YACd,OAAO,CAAC,KAAK,CAAC;YACd,OAAO,CAAC,KAAK,CAAC;YACd,MAAM,CAAC,KAAK,CAAC;YACb,QAAQ,CAAC,KAAK,CAAC,EACjB;YACE,mCAAmC;YACnC,OAAO;SACV;QACD,uDAAuD;QACvD,IAAI,KAAK,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YACpC,KAAK,CAAC,cAAc,EAAE,CAAC;YAEvB,gBAAgB;YAChB,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;YAEvD,IAAI,OAAO,KAAK,QAAQ,EAAE;gBACtB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;aACrB;YAED,IAAI,OAAO,KAAK,UAAU,EAAE;gBACxB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;aACvB;SACJ;IACL,CAAC;IAED,OAAO,CAAC,KAAK;QACT,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;YAClE,KAAK,CAAC,cAAc,EAAE,CAAC;SAC1B;IACL,CAAC;IAED,MAAM,CAAC,IAAY;QACf,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAEtC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAErG,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;QAE1C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;IAED,QAAQ,CAAC,IAAY;QACjB,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAEtC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAEtG,IAAI,CAAC,aAAa,CAAC,KAAK,GAAG,GAAG,CAAC,QAAQ,EAAE,CAAC;QAE1C,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,CAAC;IAC7D,CAAC;IAEO,iBAAiB,CAAC,KAAa;QACnC,IAAI,IAAI,CAAC,SAAS,EAAE;YAChB,IAAI,CAAC,SAAS,CAAC,OAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;SAC3C;IACL,CAAC;iIAjJQ,aAAa,iGA0BP,MAAM,8BACN,UAAU,8BACV,KAAK,8BACL,KAAK;qHA7BX,aAAa;;2FAAb,aAAa;kBAVzB,SAAS;mBAAC;oBACP,QAAQ,EAAE,+BAA+B;oBACzC,QAAQ,EAAE,kBAAkB;oBAC5B,IAAI,EAAE;wBACF,QAAQ,EAAE,qBAAqB;wBAC/B,SAAS,EAAE,oBAAoB;wBAC/B,SAAS,EAAE,iBAAiB;wBAC5B,WAAW,EAAE,mBAAmB;qBACnC;iBACJ;;0BA0BQ,QAAQ;;0BAAI,IAAI;;0BAChB,SAAS;2BAAC,MAAM;;0BAChB,SAAS;2BAAC,UAAU;;0BACpB,SAAS;2BAAC,KAAK;;0BACf,SAAS;2BAAC,KAAK;4CA3BpB,OAAO;sBADN,KAAK;gBAIN,IAAI;sBADH,KAAK;gBAIN,GAAG;sBADF,KAAK;gBAIN,GAAG;sBADF,KAAK","sourcesContent":["import {\n    Attribute,\n    Directive,\n    ElementRef,\n    Input,\n    Optional,\n    Self\n} from '@angular/core';\nimport { NgControl } from '@angular/forms';\nimport {\n    END, C, V, X, A, Z, DELETE, BACKSPACE, TAB, ENTER,\n    ESCAPE, ZERO, NINE, NUMPAD_ZERO, NUMPAD_NINE, NUMPAD_MINUS, DASH,\n    FF_MINUS, LEFT_ARROW, RIGHT_ARROW, HOME, UP_ARROW, DOWN_ARROW, F1, F12\n} from '@ptsecurity/cdk/keycodes';\nimport { Subject } from 'rxjs';\n\n\nexport const BIG_STEP = 10;\nexport const SMALL_STEP = 1;\n\nexport function normalizeSplitter(value: string): string {\n    return value ? value.replace(/,/g, '.') : value;\n}\n\nexport function isFloat(value: string): boolean {\n    return /^-?\\d+\\.\\d+$/.test(value);\n}\n\nexport function isInt(value: string): boolean {\n    return /^-?\\d+$/.test(value);\n}\n\nexport function isDigit(value: string): boolean {\n    return isFloat(value) || isInt(value);\n}\n\nexport function getPrecision(value: number): number {\n    const arr = value.toString().split('.');\n\n    return arr.length === 1\n        ? 1\n        // tslint:disable-next-line:no-magic-numbers\n        :  Math.pow(10, arr[1].length);\n}\n\nexport function add(value1: number, value2: number): number {\n    const precision = Math.max(getPrecision(value1), getPrecision(value2));\n\n    return (value1 * precision + value2 * precision) / precision;\n}\n\n\n@Directive({\n    selector: `input[mcInput][type=\"number\"]`,\n    exportAs: 'mcNumericalInput',\n    host: {\n        '(blur)': 'focusChanged(false)',\n        '(focus)': 'focusChanged(true)',\n        '(paste)': 'onPaste($event)',\n        '(keydown)': 'onKeyDown($event)'\n    }\n})\nexport class McNumberInput {\n    @Input()\n    bigStep: number;\n\n    @Input()\n    step: number;\n\n    @Input()\n    min: number;\n\n    @Input()\n    max: number;\n\n    value: any;\n\n    focused: boolean = false;\n\n    readonly stateChanges: Subject<void> = new Subject<void>();\n\n    get nativeElement(): HTMLInputElement {\n        return this.elementRef.nativeElement;\n    }\n\n    constructor(\n        private elementRef: ElementRef,\n        @Optional() @Self() private ngControl: NgControl,\n        @Attribute('step') step: string,\n        @Attribute('big-step') bigStep: string,\n        @Attribute('min') min: string,\n        @Attribute('max') max: string\n    ) {\n        this.step = isDigit(step) ? parseFloat(step) : SMALL_STEP;\n        this.bigStep = isDigit(bigStep) ? parseFloat(bigStep) : BIG_STEP;\n        this.min = isDigit(min) ? parseFloat(min) : -Infinity;\n        this.max = isDigit(max) ? parseFloat(max) : Infinity;\n\n        if ('valueAsNumber' in this.nativeElement) {\n            Object.defineProperty(Object.getPrototypeOf(this.nativeElement), 'valueAsNumber', {\n                // tslint:disable-next-line:no-reserved-keywords\n                get() {\n                    const res = parseFloat(normalizeSplitter(this.value));\n\n                    return isNaN(res) ? null : res;\n                }\n            });\n        }\n    }\n\n    focusChanged(isFocused: boolean) {\n        if (isFocused !== this.focused) {\n            this.focused = isFocused;\n            this.stateChanges.next();\n        }\n    }\n\n    onKeyDown(event: KeyboardEvent) {\n        // tslint:disable-next-line:deprecation\n        const keyCode = event.keyCode;\n\n        const isCtrlA = (e) => e.keyCode === A && (e.ctrlKey || e.metaKey);\n        const isCtrlC = (e) => e.keyCode === C && (e.ctrlKey || e.metaKey);\n        const isCtrlV = (e) => e.keyCode === V && (e.ctrlKey || e.metaKey);\n        const isCtrlX = (e) => e.keyCode === X && (e.ctrlKey || e.metaKey);\n        const isCtrlZ = (e) => e.keyCode === Z && (e.ctrlKey || e.metaKey);\n\n        const isFKey = (e) => e.keyCode >= F1 && e.keyCode <= F12;\n\n        const isNumber = (e) => (e.keyCode >= ZERO && e.keyCode <= NINE) ||\n            (e.keyCode >= NUMPAD_ZERO && e.keyCode <= NUMPAD_NINE);\n\n        const isPeriod = (e) => e.key === '.' || e.key === ',';\n\n        const minuses = [NUMPAD_MINUS, DASH, FF_MINUS];\n        const serviceKeys = [DELETE, BACKSPACE, TAB, ESCAPE, ENTER];\n        const arrows = [LEFT_ARROW, RIGHT_ARROW];\n        const allowedKeys =  [HOME, END].concat(arrows).concat(serviceKeys).concat(minuses);\n\n        if (\n            minuses.includes(keyCode) &&\n            (this.nativeElement.valueAsNumber || this.min >= 0 || this.nativeElement.validity?.badInput)\n        ) {\n            event.preventDefault();\n\n            return;\n        }\n\n        if (allowedKeys.indexOf(keyCode) !== -1 ||\n            isCtrlA(event) ||\n            isCtrlC(event) ||\n            isCtrlV(event) ||\n            isCtrlX(event) ||\n            isCtrlZ(event) ||\n            isFKey(event) ||\n            isPeriod(event)\n        ) {\n            // let it happen, don't do anything\n            return;\n        }\n        // Ensure that it is not a number and stop the keypress\n        if (event.shiftKey || !isNumber(event)) {\n            event.preventDefault();\n\n            // process steps\n            const step = event.shiftKey ? this.bigStep : this.step;\n\n            if (keyCode === UP_ARROW) {\n                this.stepUp(step);\n            }\n\n            if (keyCode === DOWN_ARROW) {\n                this.stepDown(step);\n            }\n        }\n    }\n\n    onPaste(event) {\n        if (!isDigit(normalizeSplitter(event.clipboardData.getData('text')))) {\n            event.preventDefault();\n        }\n    }\n\n    stepUp(step: number) {\n        this.elementRef.nativeElement.focus();\n\n        const res = Math.max(Math.min(add(this.nativeElement.valueAsNumber || 0, step), this.max), this.min);\n\n        this.nativeElement.value = res.toString();\n\n        this.viewToModelUpdate(this.nativeElement.valueAsNumber);\n    }\n\n    stepDown(step: number) {\n        this.elementRef.nativeElement.focus();\n\n        const res = Math.min(Math.max(add(this.nativeElement.valueAsNumber || 0, -step), this.min), this.max);\n\n        this.nativeElement.value = res.toString();\n\n        this.viewToModelUpdate(this.nativeElement.valueAsNumber);\n    }\n\n    private viewToModelUpdate(value: number) {\n        if (this.ngControl) {\n            this.ngControl.control!.setValue(value);\n        }\n    }\n}\n"]}

package/esm2022/input/input-password.mjs

@@ -0,0 +1,343 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+import { Overlay, ScrollDispatcher } from '@angular/cdk/overlay';
+import { ChangeDetectionStrategy, Component, Directive, ElementRef, Inject, Input, NgZone, Optional, Self, ViewContainerRef, ViewEncapsulation } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
+import { ErrorStateMatcher, PopUpTriggers } from '@ptsecurity/mosaic/core';
+import { McFormField, McFormFieldControl } from '@ptsecurity/mosaic/form-field';
+import { MC_TOOLTIP_SCROLL_STRATEGY, McTooltipTrigger } from '@ptsecurity/mosaic/tooltip';
+import { Subject } from 'rxjs';
+import { McInputMixinBase } from './input';
+import { MC_INPUT_VALUE_ACCESSOR } from './input-value-accessor';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/cdk/bidi";
+import * as i3 from "@angular/cdk/a11y";
+import * as i4 from "@ptsecurity/mosaic/form-field";
+import * as i5 from "@angular/forms";
+import * as i6 from "@ptsecurity/mosaic/core";
+let nextUniqueId = 0;
+export class McPasswordToggle extends McTooltipTrigger {
+    get content() {
+        return this.formField.control.elementType === 'password' ?
+            this.mcTooltipHidden :
+            this._content;
+    }
+    set content(content) {
+        this._content = content;
+        this.updateData();
+    }
+    get disabled() {
+        return this._disabled === undefined ? this.formField.disabled : this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._disabled ? this.stopFocusMonitor() : this.runFocusMonitor();
+    }
+    get tabIndex() {
+        return this.disabled ? -1 : this._tabIndex;
+    }
+    set tabIndex(value) {
+        // If the specified tabIndex value is null or undefined, fall back to the default value.
+        this._tabIndex = value != null ? coerceNumberProperty(value) : 0;
+    }
+    get hidden() {
+        return this.formField.control.elementType === 'password';
+    }
+    get visibility() {
+        return this.disabled && this.formField.control.empty ? 'hidden' : 'visible';
+    }
+    constructor(overlay, elementRef, ngZone, scrollDispatcher, hostView, scrollStrategy, direction, focusMonitor, formField) {
+        super(overlay, elementRef, ngZone, scrollDispatcher, hostView, scrollStrategy, direction);
+        this.focusMonitor = focusMonitor;
+        this.formField = formField;
+        this._tabIndex = 0;
+        this.trigger = `${PopUpTriggers.Hover}`;
+        this.runFocusMonitor();
+    }
+    ngOnDestroy() {
+        this.stopFocusMonitor();
+    }
+    toggle() {
+        if (this.disabled) {
+            return;
+        }
+        this.hide();
+        const input = this.formField.control;
+        input.toggleType();
+        this.updateData();
+    }
+    runFocusMonitor() {
+        this.focusMonitor.monitor(this.elementRef)
+            .subscribe((origin) => {
+            if (origin === 'keyboard') {
+                this.show();
+            }
+            else if (origin === null) {
+                this.hide();
+            }
+        });
+    }
+    stopFocusMonitor() {
+        this.focusMonitor.stopMonitoring(this.elementRef);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McPasswordToggle, deps: [{ token: i1.Overlay }, { token: i0.ElementRef }, { token: i0.NgZone }, { token: i1.ScrollDispatcher }, { token: i0.ViewContainerRef }, { token: MC_TOOLTIP_SCROLL_STRATEGY }, { token: i2.Directionality, optional: true }, { token: i3.FocusMonitor }, { token: i4.McFormField }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.1.5", type: McPasswordToggle, selector: "mc-password-toggle", inputs: { content: ["mcTooltipNotHidden", "content"], mcTooltipHidden: "mcTooltipHidden", disabled: "disabled", tabIndex: "tabIndex" }, host: { listeners: { "click": "toggle()", "keydown.ENTER": "toggle()", "keydown.SPACE": "toggle()" }, properties: { "class.mc-eye_16": "hidden", "class.mc-eye-crossed_16": "!hidden", "style.visibility": "visibility", "attr.tabindex": "disabled ? null : tabIndex", "attr.disabled": "disabled || null" }, classAttribute: "mc-password-toggle mc" }, exportAs: ["mcPasswordToggle"], usesInheritance: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McPasswordToggle, decorators: [{
+            type: Component,
+            args: [{
+                    selector: `mc-password-toggle`,
+                    exportAs: 'mcPasswordToggle',
+                    template: '<ng-content></ng-content>',
+                    host: {
+                        class: 'mc-password-toggle mc',
+                        '[class.mc-eye_16]': 'hidden',
+                        '[class.mc-eye-crossed_16]': '!hidden',
+                        '[style.visibility]': 'visibility',
+                        '[attr.tabindex]': 'disabled ? null : tabIndex',
+                        '[attr.disabled]': 'disabled || null',
+                        '(click)': 'toggle()',
+                        '(keydown.ENTER)': 'toggle()',
+                        '(keydown.SPACE)': 'toggle()'
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.ElementRef }, { type: i0.NgZone }, { type: i1.ScrollDispatcher }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MC_TOOLTIP_SCROLL_STRATEGY]
+                }] }, { type: i2.Directionality, decorators: [{
+                    type: Optional
+                }] }, { type: i3.FocusMonitor }, { type: i4.McFormField }]; }, propDecorators: { content: [{
+                type: Input,
+                args: ['mcTooltipNotHidden']
+            }], mcTooltipHidden: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], tabIndex: [{
+                type: Input
+            }] } });
+export class McInputPassword extends McInputMixinBase {
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get disabled() {
+        if (this.ngControl?.disabled !== null) {
+            return this.ngControl.disabled;
+        }
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        // Browsers may not fire the blur event if the input is disabled too quickly.
+        // Reset from here to ensure that the element doesn't become stuck.
+        if (this.focused) {
+            this.focused = false;
+            this.stateChanges.next(null);
+        }
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this.uid;
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    // this.elementRef.nativeElement.type = this._type;
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get value() {
+        return this._inputValueAccessor.value;
+    }
+    set value(value) {
+        if (value === this.value) {
+            return;
+        }
+        this._inputValueAccessor.value = value;
+        this.stateChanges.next(null);
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    get empty() {
+        return !this.elementRef.nativeElement.value && !this.isBadInput();
+    }
+    // tslint:disable-next-line: naming-convention
+    constructor(elementRef, ngControl, parentForm, parentFormGroup, defaultErrorStateMatcher, inputValueAccessor) {
+        super(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl);
+        this.elementRef = elementRef;
+        /**
+         * Implemented as part of McFormFieldControl.
+         * @docs-private
+         */
+        this.focused = false;
+        /**
+         * Implemented as part of McFormFieldControl.
+         * @docs-private
+         */
+        this.stateChanges = new Subject();
+        this.checkRule = new Subject();
+        /**
+         * Implemented as part of McFormFieldControl.
+         * @docs-private
+         */
+        this.controlType = 'input-password';
+        this.elementType = 'password';
+        this.uid = `mc-input-${nextUniqueId++}`;
+        this._disabled = false;
+        this._required = false;
+        // If no input value accessor was explicitly specified, use the element as the input value
+        // accessor.
+        this._inputValueAccessor = inputValueAccessor || this.elementRef.nativeElement;
+        this.previousNativeValue = this.value;
+        // Force setter to be called in case id was not specified.
+        this.id = this.id;
+    }
+    ngOnChanges() {
+        this.stateChanges.next(null);
+    }
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    ngDoCheck() {
+        if (this.ngControl) {
+            // We need to re-evaluate this on every change detection cycle, because there are some
+            // error triggers that we can't subscribe to (e.g. parent form submissions). This means
+            // that whatever logic is in here has to be super lean or we risk destroying the performance.
+            this.updateErrorState();
+        }
+        // We need to dirty-check the native element's value, because there are some cases where
+        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're
+        // updating the value using `emitEvent: false`).
+        this.dirtyCheckNativeValue();
+    }
+    checkRules() {
+        this.checkRule.next();
+    }
+    toggleType() {
+        this.elementType = this.elementType === 'password' ? 'text' : 'password';
+    }
+    /** Focuses the input. */
+    focus() {
+        this.elementRef.nativeElement.focus();
+    }
+    onBlur() {
+        if (this.ngControl?.control) {
+            const control = this.ngControl.control;
+            control.updateValueAndValidity({ emitEvent: false });
+            control.statusChanges.emit(control.status);
+        }
+        this.focusChanged(false);
+    }
+    /** Callback for the cases where the focused state of the input changes. */
+    focusChanged(isFocused) {
+        if (isFocused === this.focused) {
+            return;
+        }
+        this.focused = isFocused;
+        this.stateChanges.next({ focused: this.focused });
+    }
+    onInput() {
+        // This is a noop function and is used to let Angular know whenever the value changes.
+        // Angular will run a new change detection each time the `input` event has been dispatched.
+        // It's necessary that Angular recognizes the value change, because when floatingLabel
+        // is set to false and Angular forms aren't used, the placeholder won't recognize the
+        // value changes and will not disappear.
+        // Listening to the input event wouldn't be necessary when the input is using the
+        // FormsModule or ReactiveFormsModule, because Angular forms also listens to input events.
+    }
+    /**
+     * Implemented as part of McFormFieldControl.
+     * @docs-private
+     */
+    onContainerClick() {
+        this.focus();
+    }
+    /** Does some manual dirty checking on the native input `value` property. */
+    dirtyCheckNativeValue() {
+        if (this.previousNativeValue !== this.value) {
+            this.previousNativeValue = this.value;
+            this.stateChanges.next(null);
+        }
+    }
+    /** Checks whether the input is invalid based on the native validation. */
+    isBadInput() {
+        // The `validity` property won't be present on platform-server.
+        return this.elementRef.nativeElement.validity?.badInput;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputPassword, deps: [{ token: i0.ElementRef }, { token: i5.NgControl, optional: true, self: true }, { token: i5.NgForm, optional: true }, { token: i5.FormGroupDirective, optional: true }, { token: i6.ErrorStateMatcher }, { token: MC_INPUT_VALUE_ACCESSOR, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: McInputPassword, selector: "input[mcInputPassword]", inputs: { errorStateMatcher: "errorStateMatcher", placeholder: "placeholder", disabled: "disabled", id: "id", required: "required", value: "value" }, host: { listeners: { "blur": "onBlur()", "focus": "focusChanged(true)", "input": "onInput()" }, properties: { "attr.id": "id", "attr.type": "elementType", "attr.placeholder": "placeholder", "attr.disabled": "disabled || null", "required": "required" }, classAttribute: "mc-input mc-input-password" }, providers: [{
+                provide: McFormFieldControl, useExisting: McInputPassword
+            }], exportAs: ["mcInputPassword"], usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: McInputPassword, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `input[mcInputPassword]`,
+                    exportAs: 'mcInputPassword',
+                    host: {
+                        class: 'mc-input mc-input-password',
+                        // Native input properties that are overwritten by Angular inputs need to be synced with
+                        // the native input element. Otherwise property bindings for those don't work.
+                        '[attr.id]': 'id',
+                        '[attr.type]': 'elementType',
+                        '[attr.placeholder]': 'placeholder',
+                        '[attr.disabled]': 'disabled || null',
+                        '[required]': 'required',
+                        '(blur)': 'onBlur()',
+                        '(focus)': 'focusChanged(true)',
+                        '(input)': 'onInput()'
+                    },
+                    providers: [{
+                            provide: McFormFieldControl, useExisting: McInputPassword
+                        }]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i5.NgControl, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }] }, { type: i5.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i5.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i6.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Self
+                }, {
+                    type: Inject,
+                    args: [MC_INPUT_VALUE_ACCESSOR]
+                }] }]; }, propDecorators: { errorStateMatcher: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-password.js","sourceRoot":"","sources":["../../../../packages/mosaic/input/input-password.ts"],"names":[],"mappings":"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","sourcesContent":["import { FocusMonitor } from '@angular/cdk/a11y';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';\nimport { Overlay, ScrollDispatcher } from '@angular/cdk/overlay';\nimport {\n    ChangeDetectionStrategy,\n    Component,\n    Directive,\n    DoCheck,\n    ElementRef,\n    EventEmitter,\n    Inject,\n    Input,\n    NgZone,\n    OnChanges,\n    OnDestroy,\n    Optional,\n    Self,\n    TemplateRef,\n    ViewContainerRef,\n    ViewEncapsulation\n} from '@angular/core';\nimport {\n    FormGroupDirective,\n    NgControl,\n    NgForm\n} from '@angular/forms';\nimport {\n    CanUpdateErrorState,\n    ErrorStateMatcher,\n    PopUpTriggers\n} from '@ptsecurity/mosaic/core';\nimport { McFormField, McFormFieldControl } from '@ptsecurity/mosaic/form-field';\nimport { MC_TOOLTIP_SCROLL_STRATEGY, McTooltipTrigger } from '@ptsecurity/mosaic/tooltip';\nimport { Subject } from 'rxjs';\n\nimport { McInputMixinBase } from './input';\nimport { MC_INPUT_VALUE_ACCESSOR } from './input-value-accessor';\n\n\nlet nextUniqueId = 0;\n\n\n@Component({\n    selector: `mc-password-toggle`,\n    exportAs: 'mcPasswordToggle',\n    template: '<ng-content></ng-content>',\n    host: {\n        class: 'mc-password-toggle mc',\n        '[class.mc-eye_16]': 'hidden',\n        '[class.mc-eye-crossed_16]': '!hidden',\n\n        '[style.visibility]': 'visibility',\n\n        '[attr.tabindex]': 'disabled ? null : tabIndex',\n        '[attr.disabled]': 'disabled || null',\n\n        '(click)': 'toggle()',\n        '(keydown.ENTER)': 'toggle()',\n        '(keydown.SPACE)': 'toggle()'\n    },\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None\n})\nexport class McPasswordToggle extends McTooltipTrigger implements OnDestroy {\n    @Input('mcTooltipNotHidden')\n    get content(): string | TemplateRef<any> {\n        return (this.formField.control as McInputPassword).elementType === 'password' ?\n            this.mcTooltipHidden :\n            this._content;\n    }\n\n    set content(content: string | TemplateRef<any>) {\n        this._content = content;\n\n        this.updateData();\n    }\n\n    @Input() mcTooltipHidden: string | TemplateRef<any>;\n\n    @Input()\n    get disabled() {\n        return this._disabled === undefined ? this.formField.disabled : this._disabled;\n    }\n\n    set disabled(value: any) {\n        this._disabled = coerceBooleanProperty(value);\n\n        this._disabled ? this.stopFocusMonitor() : this.runFocusMonitor();\n    }\n\n    // tslint:disable-next-line:naming-convention\n    protected _disabled: boolean;\n\n    @Input()\n    get tabIndex(): number {\n        return this.disabled ? -1 : this._tabIndex;\n    }\n\n    set tabIndex(value: number) {\n        // If the specified tabIndex value is null or undefined, fall back to the default value.\n        this._tabIndex = value != null ? coerceNumberProperty(value) : 0;\n    }\n\n    private _tabIndex: number = 0;\n\n    get hidden(): boolean {\n        return (this.formField.control as McInputPassword).elementType === 'password';\n    }\n\n    get visibility(): string {\n        return this.disabled && this.formField.control.empty ? 'hidden' : 'visible';\n    }\n\n    constructor(\n        overlay: Overlay,\n        elementRef: ElementRef,\n        ngZone: NgZone,\n        scrollDispatcher: ScrollDispatcher,\n        hostView: ViewContainerRef,\n        @Inject(MC_TOOLTIP_SCROLL_STRATEGY) scrollStrategy,\n        @Optional() direction: Directionality,\n\n        private focusMonitor: FocusMonitor,\n        private formField: McFormField\n    ) {\n        super(overlay, elementRef, ngZone, scrollDispatcher, hostView, scrollStrategy, direction);\n\n        this.trigger = `${PopUpTriggers.Hover}`;\n\n        this.runFocusMonitor();\n    }\n\n    ngOnDestroy() {\n        this.stopFocusMonitor();\n    }\n\n    toggle() {\n        if (this.disabled) { return; }\n\n        this.hide();\n\n        const input = this.formField.control as McInputPassword;\n\n        input.toggleType();\n\n        this.updateData();\n    }\n\n    private runFocusMonitor() {\n        this.focusMonitor.monitor(this.elementRef)\n            .subscribe((origin) => {\n                if (origin === 'keyboard') {\n                    this.show();\n                } else if (origin === null) {\n                    this.hide();\n                }\n            });\n    }\n\n    private stopFocusMonitor() {\n        this.focusMonitor.stopMonitoring(this.elementRef);\n    }\n}\n\n@Directive({\n    selector: `input[mcInputPassword]`,\n    exportAs: 'mcInputPassword',\n    host: {\n        class: 'mc-input mc-input-password',\n        // Native input properties that are overwritten by Angular inputs need to be synced with\n        // the native input element. Otherwise property bindings for those don't work.\n        '[attr.id]': 'id',\n        '[attr.type]': 'elementType',\n        '[attr.placeholder]': 'placeholder',\n        '[attr.disabled]': 'disabled || null',\n        '[required]': 'required',\n\n        '(blur)': 'onBlur()',\n        '(focus)': 'focusChanged(true)',\n        '(input)': 'onInput()'\n    },\n    providers: [{\n        provide: McFormFieldControl, useExisting: McInputPassword\n    }]\n})\nexport class McInputPassword extends McInputMixinBase implements McFormFieldControl<any>, OnChanges, OnDestroy, DoCheck,\n    CanUpdateErrorState, OnChanges {\n\n    /** An object used to control when error messages are shown. */\n    @Input() errorStateMatcher: ErrorStateMatcher;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    focused: boolean = false;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    readonly stateChanges = new Subject<any>();\n\n    readonly checkRule = new Subject<void>();\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    controlType: string = 'input-password';\n\n    elementType: string = 'password';\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input() placeholder: string;\n\n    protected uid = `mc-input-${nextUniqueId++}`;\n    protected previousNativeValue: any;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get disabled(): boolean {\n        if (this.ngControl?.disabled !== null) {\n            return this.ngControl.disabled;\n        }\n\n        return this._disabled;\n    }\n\n    set disabled(value: boolean) {\n        this._disabled = coerceBooleanProperty(value);\n\n        // Browsers may not fire the blur event if the input is disabled too quickly.\n        // Reset from here to ensure that the element doesn't become stuck.\n        if (this.focused) {\n            this.focused = false;\n            this.stateChanges.next(null);\n        }\n    }\n\n    private _disabled = false;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get id(): string {\n        return this._id;\n    }\n\n    set id(value: string) {\n        this._id = value || this.uid;\n    }\n\n    private _id: string;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get required(): boolean {\n        return this._required;\n    }\n\n    set required(value: boolean) {\n        this._required = coerceBooleanProperty(value);\n    }\n\n    private _required = false;\n\n    // this.elementRef.nativeElement.type = this._type;\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    @Input()\n    get value(): string {\n        return this._inputValueAccessor.value;\n    }\n\n    set value(value: string) {\n        if (value === this.value) { return; }\n\n        this._inputValueAccessor.value = value;\n        this.stateChanges.next(null);\n    }\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    get empty(): boolean {\n        return !this.elementRef.nativeElement.value && !this.isBadInput();\n    }\n\n    // tslint:disable-next-line: orthodox-getter-and-setter\n    private _inputValueAccessor: { value: any };\n\n    // tslint:disable-next-line: naming-convention\n    constructor(\n        protected elementRef: ElementRef,\n        @Optional() @Self() ngControl: NgControl,\n        @Optional() parentForm: NgForm,\n        @Optional() parentFormGroup: FormGroupDirective,\n        defaultErrorStateMatcher: ErrorStateMatcher,\n        @Optional() @Self() @Inject(MC_INPUT_VALUE_ACCESSOR) inputValueAccessor: any\n    ) {\n        super(defaultErrorStateMatcher, parentForm, parentFormGroup, ngControl);\n\n        // If no input value accessor was explicitly specified, use the element as the input value\n        // accessor.\n        this._inputValueAccessor = inputValueAccessor || this.elementRef.nativeElement;\n\n        this.previousNativeValue = this.value;\n\n        // Force setter to be called in case id was not specified.\n        this.id = this.id;\n    }\n\n    ngOnChanges() {\n        this.stateChanges.next(null);\n    }\n\n    ngOnDestroy() {\n        this.stateChanges.complete();\n    }\n\n    ngDoCheck() {\n        if (this.ngControl) {\n            // We need to re-evaluate this on every change detection cycle, because there are some\n            // error triggers that we can't subscribe to (e.g. parent form submissions). This means\n            // that whatever logic is in here has to be super lean or we risk destroying the performance.\n            this.updateErrorState();\n        }\n\n        // We need to dirty-check the native element's value, because there are some cases where\n        // we won't be notified when it changes (e.g. the consumer isn't using forms or they're\n        // updating the value using `emitEvent: false`).\n        this.dirtyCheckNativeValue();\n    }\n\n    checkRules() {\n        this.checkRule.next();\n    }\n\n    toggleType() {\n        this.elementType = this.elementType === 'password' ? 'text' : 'password';\n    }\n\n    /** Focuses the input. */\n    focus(): void {\n        this.elementRef.nativeElement.focus();\n    }\n\n    onBlur(): void {\n        if (this.ngControl?.control) {\n            const control = this.ngControl.control;\n\n            control.updateValueAndValidity({ emitEvent: false });\n            (control.statusChanges as EventEmitter<string>).emit(control.status);\n        }\n\n        this.focusChanged(false);\n    }\n\n    /** Callback for the cases where the focused state of the input changes. */\n    focusChanged(isFocused: boolean) {\n        if (isFocused === this.focused) { return; }\n\n        this.focused = isFocused;\n        this.stateChanges.next({ focused: this.focused });\n    }\n\n    onInput() {\n        // This is a noop function and is used to let Angular know whenever the value changes.\n        // Angular will run a new change detection each time the `input` event has been dispatched.\n        // It's necessary that Angular recognizes the value change, because when floatingLabel\n        // is set to false and Angular forms aren't used, the placeholder won't recognize the\n        // value changes and will not disappear.\n        // Listening to the input event wouldn't be necessary when the input is using the\n        // FormsModule or ReactiveFormsModule, because Angular forms also listens to input events.\n    }\n\n    /**\n     * Implemented as part of McFormFieldControl.\n     * @docs-private\n     */\n    onContainerClick() {\n        this.focus();\n    }\n\n    /** Does some manual dirty checking on the native input `value` property. */\n    protected dirtyCheckNativeValue() {\n        if (this.previousNativeValue !== this.value) {\n            this.previousNativeValue = this.value;\n            this.stateChanges.next(null);\n        }\n    }\n\n    /** Checks whether the input is invalid based on the native validation. */\n    protected isBadInput() {\n        // The `validity` property won't be present on platform-server.\n        return (this.elementRef.nativeElement as HTMLInputElement).validity?.badInput;\n    }\n}\n"]}