You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
479 lines
62 KiB
479 lines
62 KiB
/**
|
|
* @license
|
|
* Copyright Google LLC All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by an MIT-style license that can be
|
|
* found in the LICENSE file at https://angular.io/license
|
|
*/
|
|
import { coerceBooleanProperty } from '@angular/cdk/coercion';
|
|
import { getSupportedInputTypes, Platform } from '@angular/cdk/platform';
|
|
import { AutofillMonitor } from '@angular/cdk/text-field';
|
|
import { Directive, ElementRef, HostListener, Inject, Input, NgZone, Optional, Self, } from '@angular/core';
|
|
import { FormGroupDirective, NgControl, NgForm } from '@angular/forms';
|
|
import { ErrorStateMatcher, mixinErrorState, } from '@angular/material/core';
|
|
import { MatFormFieldControl, MatFormField, MAT_FORM_FIELD } from '@angular/material/form-field';
|
|
import { Subject } from 'rxjs';
|
|
import { getMatInputUnsupportedTypeError } from './input-errors';
|
|
import { MAT_INPUT_VALUE_ACCESSOR } from './input-value-accessor';
|
|
// Invalid input type. Using one of these will throw an MatInputUnsupportedTypeError.
|
|
import * as ɵngcc0 from '@angular/core';
|
|
import * as ɵngcc1 from '@angular/cdk/platform';
|
|
import * as ɵngcc2 from '@angular/forms';
|
|
import * as ɵngcc3 from '@angular/material/core';
|
|
import * as ɵngcc4 from '@angular/cdk/text-field';
|
|
import * as ɵngcc5 from '@angular/material/form-field';
|
|
const MAT_INPUT_INVALID_TYPES = [
|
|
'button',
|
|
'checkbox',
|
|
'file',
|
|
'hidden',
|
|
'image',
|
|
'radio',
|
|
'range',
|
|
'reset',
|
|
'submit'
|
|
];
|
|
let nextUniqueId = 0;
|
|
// Boilerplate for applying mixins to MatInput.
|
|
/** @docs-private */
|
|
const _MatInputBase = mixinErrorState(class {
|
|
constructor(_defaultErrorStateMatcher, _parentForm, _parentFormGroup,
|
|
/** @docs-private */
|
|
ngControl) {
|
|
this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
|
|
this._parentForm = _parentForm;
|
|
this._parentFormGroup = _parentFormGroup;
|
|
this.ngControl = ngControl;
|
|
}
|
|
});
|
|
/** Directive that allows a native input to work inside a `MatFormField`. */
|
|
export class MatInput extends _MatInputBase {
|
|
constructor(_elementRef, _platform, ngControl, _parentForm, _parentFormGroup, _defaultErrorStateMatcher, inputValueAccessor, _autofillMonitor, ngZone,
|
|
// TODO: Remove this once the legacy appearance has been removed. We only need
|
|
// to inject the form-field for determining whether the placeholder has been promoted.
|
|
_formField) {
|
|
super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);
|
|
this._elementRef = _elementRef;
|
|
this._platform = _platform;
|
|
this._autofillMonitor = _autofillMonitor;
|
|
this._formField = _formField;
|
|
this._uid = `mat-input-${nextUniqueId++}`;
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
this.focused = false;
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
this.stateChanges = new Subject();
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
this.controlType = 'mat-input';
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
this.autofilled = false;
|
|
this._disabled = false;
|
|
this._required = false;
|
|
this._type = 'text';
|
|
this._readonly = false;
|
|
this._neverEmptyInputTypes = [
|
|
'date',
|
|
'datetime',
|
|
'datetime-local',
|
|
'month',
|
|
'time',
|
|
'week'
|
|
].filter(t => getSupportedInputTypes().has(t));
|
|
const element = this._elementRef.nativeElement;
|
|
const nodeName = element.nodeName.toLowerCase();
|
|
// If no input value accessor was explicitly specified, use the element as the input value
|
|
// accessor.
|
|
this._inputValueAccessor = inputValueAccessor || element;
|
|
this._previousNativeValue = this.value;
|
|
// Force setter to be called in case id was not specified.
|
|
this.id = this.id;
|
|
// On some versions of iOS the caret gets stuck in the wrong place when holding down the delete
|
|
// key. In order to get around this we need to "jiggle" the caret loose. Since this bug only
|
|
// exists on iOS, we only bother to install the listener on iOS.
|
|
if (_platform.IOS) {
|
|
ngZone.runOutsideAngular(() => {
|
|
_elementRef.nativeElement.addEventListener('keyup', (event) => {
|
|
const el = event.target;
|
|
// Note: We specifically check for 0, rather than `!el.selectionStart`, because the two
|
|
// indicate different things. If the value is 0, it means that the caret is at the start
|
|
// of the input, whereas a value of `null` means that the input doesn't support
|
|
// manipulating the selection range. Inputs that don't support setting the selection range
|
|
// will throw an error so we want to avoid calling `setSelectionRange` on them. See:
|
|
// https://html.spec.whatwg.org/multipage/input.html#do-not-apply
|
|
if (!el.value && el.selectionStart === 0 && el.selectionEnd === 0) {
|
|
// Note: Just setting `0, 0` doesn't fix the issue. Setting
|
|
// `1, 1` fixes it for the first time that you type text and
|
|
// then hold delete. Toggling to `1, 1` and then back to
|
|
// `0, 0` seems to completely fix it.
|
|
el.setSelectionRange(1, 1);
|
|
el.setSelectionRange(0, 0);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
this._isServer = !this._platform.isBrowser;
|
|
this._isNativeSelect = nodeName === 'select';
|
|
this._isTextarea = nodeName === 'textarea';
|
|
this._isInFormField = !!_formField;
|
|
if (this._isNativeSelect) {
|
|
this.controlType = element.multiple ? 'mat-native-select-multiple' :
|
|
'mat-native-select';
|
|
}
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
get disabled() {
|
|
if (this.ngControl && 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();
|
|
}
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
get id() { return this._id; }
|
|
set id(value) { this._id = value || this._uid; }
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
get required() { return this._required; }
|
|
set required(value) { this._required = coerceBooleanProperty(value); }
|
|
/** Input type of the element. */
|
|
get type() { return this._type; }
|
|
set type(value) {
|
|
this._type = value || 'text';
|
|
this._validateType();
|
|
// When using Angular inputs, developers are no longer able to set the properties on the native
|
|
// input element. To ensure that bindings for `type` work, we need to sync the setter
|
|
// with the native property. Textarea elements don't support the type property or attribute.
|
|
if (!this._isTextarea && getSupportedInputTypes().has(this._type)) {
|
|
this._elementRef.nativeElement.type = this._type;
|
|
}
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
get value() { return this._inputValueAccessor.value; }
|
|
set value(value) {
|
|
if (value !== this.value) {
|
|
this._inputValueAccessor.value = value;
|
|
this.stateChanges.next();
|
|
}
|
|
}
|
|
/** Whether the element is readonly. */
|
|
get readonly() { return this._readonly; }
|
|
set readonly(value) { this._readonly = coerceBooleanProperty(value); }
|
|
ngAfterViewInit() {
|
|
if (this._platform.isBrowser) {
|
|
this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(event => {
|
|
this.autofilled = event.isAutofilled;
|
|
this.stateChanges.next();
|
|
});
|
|
}
|
|
}
|
|
ngOnChanges() {
|
|
this.stateChanges.next();
|
|
}
|
|
ngOnDestroy() {
|
|
this.stateChanges.complete();
|
|
if (this._platform.isBrowser) {
|
|
this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement);
|
|
}
|
|
}
|
|
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();
|
|
// We need to dirty-check and set the placeholder attribute ourselves, because whether it's
|
|
// present or not depends on a query which is prone to "changed after checked" errors.
|
|
this._dirtyCheckPlaceholder();
|
|
}
|
|
/** Focuses the input. */
|
|
focus(options) {
|
|
this._elementRef.nativeElement.focus(options);
|
|
}
|
|
// We have to use a `HostListener` here in order to support both Ivy and ViewEngine.
|
|
// In Ivy the `host` bindings will be merged when this class is extended, whereas in
|
|
// ViewEngine they're overwritten.
|
|
// TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.
|
|
/** Callback for the cases where the focused state of the input changes. */
|
|
// tslint:disable:no-host-decorator-in-concrete
|
|
// tslint:enable:no-host-decorator-in-concrete
|
|
_focusChanged(isFocused) {
|
|
if (isFocused !== this.focused) {
|
|
this.focused = isFocused;
|
|
this.stateChanges.next();
|
|
}
|
|
}
|
|
// We have to use a `HostListener` here in order to support both Ivy and ViewEngine.
|
|
// In Ivy the `host` bindings will be merged when this class is extended, whereas in
|
|
// ViewEngine they're overwritten.
|
|
// TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.
|
|
// tslint:disable-next-line:no-host-decorator-in-concrete
|
|
_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.
|
|
}
|
|
/** Does some manual dirty checking on the native input `placeholder` attribute. */
|
|
_dirtyCheckPlaceholder() {
|
|
var _a, _b;
|
|
// If we're hiding the native placeholder, it should also be cleared from the DOM, otherwise
|
|
// screen readers will read it out twice: once from the label and once from the attribute.
|
|
// TODO: can be removed once we get rid of the `legacy` style for the form field, because it's
|
|
// the only one that supports promoting the placeholder to a label.
|
|
const placeholder = ((_b = (_a = this._formField) === null || _a === void 0 ? void 0 : _a._hideControlPlaceholder) === null || _b === void 0 ? void 0 : _b.call(_a)) ? null : this.placeholder;
|
|
if (placeholder !== this._previousPlaceholder) {
|
|
const element = this._elementRef.nativeElement;
|
|
this._previousPlaceholder = placeholder;
|
|
placeholder ?
|
|
element.setAttribute('placeholder', placeholder) : element.removeAttribute('placeholder');
|
|
}
|
|
}
|
|
/** Does some manual dirty checking on the native input `value` property. */
|
|
_dirtyCheckNativeValue() {
|
|
const newValue = this._elementRef.nativeElement.value;
|
|
if (this._previousNativeValue !== newValue) {
|
|
this._previousNativeValue = newValue;
|
|
this.stateChanges.next();
|
|
}
|
|
}
|
|
/** Make sure the input is a supported type. */
|
|
_validateType() {
|
|
if (MAT_INPUT_INVALID_TYPES.indexOf(this._type) > -1 &&
|
|
(typeof ngDevMode === 'undefined' || ngDevMode)) {
|
|
throw getMatInputUnsupportedTypeError(this._type);
|
|
}
|
|
}
|
|
/** Checks whether the input type is one of the types that are never empty. */
|
|
_isNeverEmpty() {
|
|
return this._neverEmptyInputTypes.indexOf(this._type) > -1;
|
|
}
|
|
/** Checks whether the input is invalid based on the native validation. */
|
|
_isBadInput() {
|
|
// The `validity` property won't be present on platform-server.
|
|
let validity = this._elementRef.nativeElement.validity;
|
|
return validity && validity.badInput;
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
get empty() {
|
|
return !this._isNeverEmpty() && !this._elementRef.nativeElement.value && !this._isBadInput() &&
|
|
!this.autofilled;
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
get shouldLabelFloat() {
|
|
if (this._isNativeSelect) {
|
|
// For a single-selection `<select>`, the label should float when the selected option has
|
|
// a non-empty display value. For a `<select multiple>`, the label *always* floats to avoid
|
|
// overlapping the label with the options.
|
|
const selectElement = this._elementRef.nativeElement;
|
|
const firstOption = selectElement.options[0];
|
|
// On most browsers the `selectedIndex` will always be 0, however on IE and Edge it'll be
|
|
// -1 if the `value` is set to something, that isn't in the list of options, at a later point.
|
|
return this.focused || selectElement.multiple || !this.empty ||
|
|
!!(selectElement.selectedIndex > -1 && firstOption && firstOption.label);
|
|
}
|
|
else {
|
|
return this.focused || !this.empty;
|
|
}
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
setDescribedByIds(ids) {
|
|
if (ids.length) {
|
|
this._elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));
|
|
}
|
|
else {
|
|
this._elementRef.nativeElement.removeAttribute('aria-describedby');
|
|
}
|
|
}
|
|
/**
|
|
* Implemented as part of MatFormFieldControl.
|
|
* @docs-private
|
|
*/
|
|
onContainerClick() {
|
|
// Do not re-focus the input element if the element is already focused. Otherwise it can happen
|
|
// that someone clicks on a time input and the cursor resets to the "hours" field while the
|
|
// "minutes" field was actually clicked. See: https://github.com/angular/components/issues/12849
|
|
if (!this.focused) {
|
|
this.focus();
|
|
}
|
|
}
|
|
/** Whether the form control is a native select that is displayed inline. */
|
|
_isInlineSelect() {
|
|
const element = this._elementRef.nativeElement;
|
|
return this._isNativeSelect && (element.multiple || element.size > 1);
|
|
}
|
|
}
|
|
MatInput.ɵfac = function MatInput_Factory(t) { return new (t || MatInput)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Platform), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgControl, 10), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.NgForm, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.FormGroupDirective, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc3.ErrorStateMatcher), ɵngcc0.ɵɵdirectiveInject(MAT_INPUT_VALUE_ACCESSOR, 10), ɵngcc0.ɵɵdirectiveInject(ɵngcc4.AutofillMonitor), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.NgZone), ɵngcc0.ɵɵdirectiveInject(MAT_FORM_FIELD, 8)); };
|
|
MatInput.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: MatInput, selectors: [["input", "matInput", ""], ["textarea", "matInput", ""], ["select", "matNativeControl", ""], ["input", "matNativeControl", ""], ["textarea", "matNativeControl", ""]], hostAttrs: [1, "mat-input-element", "mat-form-field-autofill-control"], hostVars: 11, hostBindings: function MatInput_HostBindings(rf, ctx) { if (rf & 1) {
|
|
ɵngcc0.ɵɵlistener("focus", function MatInput_focus_HostBindingHandler() { return ctx._focusChanged(true); })("blur", function MatInput_blur_HostBindingHandler() { return ctx._focusChanged(false); })("input", function MatInput_input_HostBindingHandler() { return ctx._onInput(); });
|
|
} if (rf & 2) {
|
|
ɵngcc0.ɵɵhostProperty("disabled", ctx.disabled)("required", ctx.required);
|
|
ɵngcc0.ɵɵattribute("id", ctx.id)("data-placeholder", ctx.placeholder)("readonly", ctx.readonly && !ctx._isNativeSelect || null)("aria-invalid", ctx.empty && ctx.required ? null : ctx.errorState)("aria-required", ctx.required);
|
|
ɵngcc0.ɵɵclassProp("mat-input-server", ctx._isServer)("mat-native-select-inline", ctx._isInlineSelect());
|
|
} }, inputs: { id: "id", disabled: "disabled", required: "required", type: "type", value: "value", readonly: "readonly", placeholder: "placeholder", errorStateMatcher: "errorStateMatcher", userAriaDescribedBy: ["aria-describedby", "userAriaDescribedBy"] }, exportAs: ["matInput"], features: [ɵngcc0.ɵɵProvidersFeature([{ provide: MatFormFieldControl, useExisting: MatInput }]), ɵngcc0.ɵɵInheritDefinitionFeature, ɵngcc0.ɵɵNgOnChangesFeature] });
|
|
MatInput.ctorParameters = () => [
|
|
{ type: ElementRef },
|
|
{ type: Platform },
|
|
{ type: NgControl, decorators: [{ type: Optional }, { type: Self }] },
|
|
{ type: NgForm, decorators: [{ type: Optional }] },
|
|
{ type: FormGroupDirective, decorators: [{ type: Optional }] },
|
|
{ type: ErrorStateMatcher },
|
|
{ type: undefined, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [MAT_INPUT_VALUE_ACCESSOR,] }] },
|
|
{ type: AutofillMonitor },
|
|
{ type: NgZone },
|
|
{ type: MatFormField, decorators: [{ type: Optional }, { type: Inject, args: [MAT_FORM_FIELD,] }] }
|
|
];
|
|
MatInput.propDecorators = {
|
|
disabled: [{ type: Input }],
|
|
id: [{ type: Input }],
|
|
placeholder: [{ type: Input }],
|
|
required: [{ type: Input }],
|
|
type: [{ type: Input }],
|
|
errorStateMatcher: [{ type: Input }],
|
|
userAriaDescribedBy: [{ type: Input, args: ['aria-describedby',] }],
|
|
value: [{ type: Input }],
|
|
readonly: [{ type: Input }],
|
|
_focusChanged: [{ type: HostListener, args: ['focus', ['true'],] }, { type: HostListener, args: ['blur', ['false'],] }],
|
|
_onInput: [{ type: HostListener, args: ['input',] }]
|
|
};
|
|
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MatInput, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: `input[matInput], textarea[matInput], select[matNativeControl],
|
|
input[matNativeControl], textarea[matNativeControl]`,
|
|
exportAs: 'matInput',
|
|
host: {
|
|
/**
|
|
* @breaking-change 8.0.0 remove .mat-form-field-autofill-control in favor of AutofillMonitor.
|
|
*/
|
|
'class': 'mat-input-element mat-form-field-autofill-control',
|
|
'[class.mat-input-server]': '_isServer',
|
|
// 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',
|
|
// At the time of writing, we have a lot of customer tests that look up the input based on its
|
|
// placeholder. Since we sometimes omit the placeholder attribute from the DOM to prevent screen
|
|
// readers from reading it twice, we have to keep it somewhere in the DOM for the lookup.
|
|
'[attr.data-placeholder]': 'placeholder',
|
|
'[disabled]': 'disabled',
|
|
'[required]': 'required',
|
|
'[attr.readonly]': 'readonly && !_isNativeSelect || null',
|
|
'[class.mat-native-select-inline]': '_isInlineSelect()',
|
|
// Only mark the input as invalid for assistive technology if it has a value since the
|
|
// state usually overlaps with `aria-required` when the input is empty and can be redundant.
|
|
'[attr.aria-invalid]': '(empty && required) ? null : errorState',
|
|
'[attr.aria-required]': 'required'
|
|
},
|
|
providers: [{ provide: MatFormFieldControl, useExisting: MatInput }]
|
|
}]
|
|
}], function () { return [{ type: ɵngcc0.ElementRef }, { type: ɵngcc1.Platform }, { type: ɵngcc2.NgControl, decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Self
|
|
}] }, { type: ɵngcc2.NgForm, decorators: [{
|
|
type: Optional
|
|
}] }, { type: ɵngcc2.FormGroupDirective, decorators: [{
|
|
type: Optional
|
|
}] }, { type: ɵngcc3.ErrorStateMatcher }, { type: undefined, decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Self
|
|
}, {
|
|
type: Inject,
|
|
args: [MAT_INPUT_VALUE_ACCESSOR]
|
|
}] }, { type: ɵngcc4.AutofillMonitor }, { type: ɵngcc0.NgZone }, { type: ɵngcc5.MatFormField, decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Inject,
|
|
args: [MAT_FORM_FIELD]
|
|
}] }]; }, { id: [{
|
|
type: Input
|
|
}], disabled: [{
|
|
type: Input
|
|
}], required: [{
|
|
type: Input
|
|
}], type: [{
|
|
type: Input
|
|
}], value: [{
|
|
type: Input
|
|
}], readonly: [{
|
|
type: Input
|
|
}],
|
|
// We have to use a `HostListener` here in order to support both Ivy and ViewEngine.
|
|
// In Ivy the `host` bindings will be merged when this class is extended, whereas in
|
|
// ViewEngine they're overwritten.
|
|
// TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.
|
|
/** Callback for the cases where the focused state of the input changes. */
|
|
// tslint:disable:no-host-decorator-in-concrete
|
|
// tslint:enable:no-host-decorator-in-concrete
|
|
_focusChanged: [{
|
|
type: HostListener,
|
|
args: ['focus', ['true']]
|
|
}, {
|
|
type: HostListener,
|
|
args: ['blur', ['false']]
|
|
}],
|
|
// We have to use a `HostListener` here in order to support both Ivy and ViewEngine.
|
|
// In Ivy the `host` bindings will be merged when this class is extended, whereas in
|
|
// ViewEngine they're overwritten.
|
|
// TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.
|
|
// tslint:disable-next-line:no-host-decorator-in-concrete
|
|
_onInput: [{
|
|
type: HostListener,
|
|
args: ['input']
|
|
}], placeholder: [{
|
|
type: Input
|
|
}], errorStateMatcher: [{
|
|
type: Input
|
|
}], userAriaDescribedBy: [{
|
|
type: Input,
|
|
args: ['aria-describedby']
|
|
}] }); })();
|
|
|
|
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"input.js","sources":["../../../../../../src/material/input/input.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {BooleanInput, coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {getSupportedInputTypes, Platform} from '@angular/cdk/platform';\nimport {AutofillMonitor} from '@angular/cdk/text-field';\nimport {\n  AfterViewInit,\n  Directive,\n  DoCheck,\n  ElementRef,\n  HostListener,\n  Inject,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Self,\n} from '@angular/core';\nimport {FormGroupDirective, NgControl, NgForm} from '@angular/forms';\nimport {\n  CanUpdateErrorState,\n  ErrorStateMatcher,\n  mixinErrorState,\n} from '@angular/material/core';\nimport {MatFormFieldControl, MatFormField, MAT_FORM_FIELD} from '@angular/material/form-field';\nimport {Subject} from 'rxjs';\nimport {getMatInputUnsupportedTypeError} from './input-errors';\nimport {MAT_INPUT_VALUE_ACCESSOR} from './input-value-accessor';\n\n\n// Invalid input type. Using one of these will throw an MatInputUnsupportedTypeError.\nconst MAT_INPUT_INVALID_TYPES = [\n  'button',\n  'checkbox',\n  'file',\n  'hidden',\n  'image',\n  'radio',\n  'range',\n  'reset',\n  'submit'\n];\n\nlet nextUniqueId = 0;\n\n// Boilerplate for applying mixins to MatInput.\n/** @docs-private */\nconst _MatInputBase = mixinErrorState(class {\n  constructor(public _defaultErrorStateMatcher: ErrorStateMatcher,\n              public _parentForm: NgForm,\n              public _parentFormGroup: FormGroupDirective,\n              /** @docs-private */\n              public ngControl: NgControl) {}\n});\n\n/** Directive that allows a native input to work inside a `MatFormField`. */\n@Directive({\n  selector: `input[matInput], textarea[matInput], select[matNativeControl],\n      input[matNativeControl], textarea[matNativeControl]`,\n  exportAs: 'matInput',\n  host: {\n    /**\n     * @breaking-change 8.0.0 remove .mat-form-field-autofill-control in favor of AutofillMonitor.\n     */\n    'class': 'mat-input-element mat-form-field-autofill-control',\n    '[class.mat-input-server]': '_isServer',\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    // At the time of writing, we have a lot of customer tests that look up the input based on its\n    // placeholder. Since we sometimes omit the placeholder attribute from the DOM to prevent screen\n    // readers from reading it twice, we have to keep it somewhere in the DOM for the lookup.\n    '[attr.data-placeholder]': 'placeholder',\n    '[disabled]': 'disabled',\n    '[required]': 'required',\n    '[attr.readonly]': 'readonly && !_isNativeSelect || null',\n    '[class.mat-native-select-inline]': '_isInlineSelect()',\n    // Only mark the input as invalid for assistive technology if it has a value since the\n    // state usually overlaps with `aria-required` when the input is empty and can be redundant.\n    '[attr.aria-invalid]': '(empty && required) ? null : errorState',\n    '[attr.aria-required]': 'required',\n  },\n  providers: [{provide: MatFormFieldControl, useExisting: MatInput}],\n})\nexport class MatInput extends _MatInputBase implements MatFormFieldControl<any>, OnChanges,\n    OnDestroy, AfterViewInit, DoCheck, CanUpdateErrorState {\n  protected _uid = `mat-input-${nextUniqueId++}`;\n  protected _previousNativeValue: any;\n  private _inputValueAccessor: {value: any};\n  private _previousPlaceholder: string | null;\n\n  /** Whether the component is being rendered on the server. */\n  readonly _isServer: boolean;\n\n  /** Whether the component is a native html select. */\n  readonly _isNativeSelect: boolean;\n\n  /** Whether the component is a textarea. */\n  readonly _isTextarea: boolean;\n\n  /** Whether the input is inside of a form field. */\n  readonly _isInFormField: boolean;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  focused: boolean = false;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  override readonly stateChanges: Subject<void> = new Subject<void>();\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  controlType: string = 'mat-input';\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  autofilled = false;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  @Input()\n  get disabled(): boolean {\n    if (this.ngControl && this.ngControl.disabled !== null) {\n      return this.ngControl.disabled;\n    }\n    return this._disabled;\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();\n    }\n  }\n  protected _disabled = false;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  @Input()\n  get id(): string { return this._id; }\n  set id(value: string) { this._id = value || this._uid; }\n  protected _id: string;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  @Input() placeholder: string;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  @Input()\n  get required(): boolean { return this._required; }\n  set required(value: boolean) { this._required = coerceBooleanProperty(value); }\n  protected _required = false;\n\n  /** Input type of the element. */\n  @Input()\n  get type(): string { return this._type; }\n  set type(value: string) {\n    this._type = value || 'text';\n    this._validateType();\n\n    // When using Angular inputs, developers are no longer able to set the properties on the native\n    // input element. To ensure that bindings for `type` work, we need to sync the setter\n    // with the native property. Textarea elements don't support the type property or attribute.\n    if (!this._isTextarea && getSupportedInputTypes().has(this._type)) {\n      (this._elementRef.nativeElement as HTMLInputElement).type = this._type;\n    }\n  }\n  protected _type = 'text';\n\n  /** An object used to control when error messages are shown. */\n  @Input() override errorStateMatcher: ErrorStateMatcher;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  @Input('aria-describedby') userAriaDescribedBy: string;\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  @Input()\n  get value(): string { return this._inputValueAccessor.value; }\n  set value(value: string) {\n    if (value !== this.value) {\n      this._inputValueAccessor.value = value;\n      this.stateChanges.next();\n    }\n  }\n\n  /** Whether the element is readonly. */\n  @Input()\n  get readonly(): boolean { return this._readonly; }\n  set readonly(value: boolean) { this._readonly = coerceBooleanProperty(value); }\n  private _readonly = false;\n\n  protected _neverEmptyInputTypes = [\n    'date',\n    'datetime',\n    'datetime-local',\n    'month',\n    'time',\n    'week'\n  ].filter(t => getSupportedInputTypes().has(t));\n\n  constructor(\n      protected _elementRef: ElementRef<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement>,\n      protected _platform: Platform,\n      @Optional() @Self() ngControl: NgControl,\n      @Optional() _parentForm: NgForm,\n      @Optional() _parentFormGroup: FormGroupDirective,\n      _defaultErrorStateMatcher: ErrorStateMatcher,\n      @Optional() @Self() @Inject(MAT_INPUT_VALUE_ACCESSOR) inputValueAccessor: any,\n      private _autofillMonitor: AutofillMonitor,\n      ngZone: NgZone,\n      // TODO: Remove this once the legacy appearance has been removed. We only need\n      // to inject the form-field for determining whether the placeholder has been promoted.\n      @Optional() @Inject(MAT_FORM_FIELD) private _formField?: MatFormField) {\n\n    super(_defaultErrorStateMatcher, _parentForm, _parentFormGroup, ngControl);\n\n    const element = this._elementRef.nativeElement;\n    const nodeName = element.nodeName.toLowerCase();\n\n    // If no input value accessor was explicitly specified, use the element as the input value\n    // accessor.\n    this._inputValueAccessor = inputValueAccessor || element;\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    // On some versions of iOS the caret gets stuck in the wrong place when holding down the delete\n    // key. In order to get around this we need to \"jiggle\" the caret loose. Since this bug only\n    // exists on iOS, we only bother to install the listener on iOS.\n    if (_platform.IOS) {\n      ngZone.runOutsideAngular(() => {\n        _elementRef.nativeElement.addEventListener('keyup', (event: Event) => {\n          const el = event.target as HTMLInputElement;\n\n          // Note: We specifically check for 0, rather than `!el.selectionStart`, because the two\n          // indicate different things. If the value is 0, it means that the caret is at the start\n          // of the input, whereas a value of `null` means that the input doesn't support\n          // manipulating the selection range. Inputs that don't support setting the selection range\n          // will throw an error so we want to avoid calling `setSelectionRange` on them. See:\n          // https://html.spec.whatwg.org/multipage/input.html#do-not-apply\n          if (!el.value && el.selectionStart === 0 && el.selectionEnd === 0) {\n            // Note: Just setting `0, 0` doesn't fix the issue. Setting\n            // `1, 1` fixes it for the first time that you type text and\n            // then hold delete. Toggling to `1, 1` and then back to\n            // `0, 0` seems to completely fix it.\n            el.setSelectionRange(1, 1);\n            el.setSelectionRange(0, 0);\n          }\n        });\n      });\n    }\n\n    this._isServer = !this._platform.isBrowser;\n    this._isNativeSelect = nodeName === 'select';\n    this._isTextarea = nodeName === 'textarea';\n    this._isInFormField = !!_formField;\n\n    if (this._isNativeSelect) {\n      this.controlType = (element as HTMLSelectElement).multiple ? 'mat-native-select-multiple' :\n                                                                   'mat-native-select';\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this._platform.isBrowser) {\n      this._autofillMonitor.monitor(this._elementRef.nativeElement).subscribe(event => {\n        this.autofilled = event.isAutofilled;\n        this.stateChanges.next();\n      });\n    }\n  }\n\n  ngOnChanges() {\n    this.stateChanges.next();\n  }\n\n  ngOnDestroy() {\n    this.stateChanges.complete();\n\n    if (this._platform.isBrowser) {\n      this._autofillMonitor.stopMonitoring(this._elementRef.nativeElement);\n    }\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    // We need to dirty-check and set the placeholder attribute ourselves, because whether it's\n    // present or not depends on a query which is prone to \"changed after checked\" errors.\n    this._dirtyCheckPlaceholder();\n  }\n\n  /** Focuses the input. */\n  focus(options?: FocusOptions): void {\n    this._elementRef.nativeElement.focus(options);\n  }\n\n  // We have to use a `HostListener` here in order to support both Ivy and ViewEngine.\n  // In Ivy the `host` bindings will be merged when this class is extended, whereas in\n  // ViewEngine they're overwritten.\n  // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.\n  /** Callback for the cases where the focused state of the input changes. */\n  // tslint:disable:no-host-decorator-in-concrete\n  @HostListener('focus', ['true'])\n  @HostListener('blur', ['false'])\n  // tslint:enable:no-host-decorator-in-concrete\n  _focusChanged(isFocused: boolean) {\n    if (isFocused !== this.focused) {\n      this.focused = isFocused;\n      this.stateChanges.next();\n    }\n  }\n\n  // We have to use a `HostListener` here in order to support both Ivy and ViewEngine.\n  // In Ivy the `host` bindings will be merged when this class is extended, whereas in\n  // ViewEngine they're overwritten.\n  // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default.\n  // tslint:disable-next-line:no-host-decorator-in-concrete\n  @HostListener('input')\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  /** Does some manual dirty checking on the native input `placeholder` attribute. */\n  private _dirtyCheckPlaceholder() {\n    // If we're hiding the native placeholder, it should also be cleared from the DOM, otherwise\n    // screen readers will read it out twice: once from the label and once from the attribute.\n    // TODO: can be removed once we get rid of the `legacy` style for the form field, because it's\n    // the only one that supports promoting the placeholder to a label.\n    const placeholder = this._formField?._hideControlPlaceholder?.() ? null : this.placeholder;\n    if (placeholder !== this._previousPlaceholder) {\n      const element = this._elementRef.nativeElement;\n      this._previousPlaceholder = placeholder;\n      placeholder ?\n          element.setAttribute('placeholder', placeholder) : element.removeAttribute('placeholder');\n    }\n  }\n\n  /** Does some manual dirty checking on the native input `value` property. */\n  protected _dirtyCheckNativeValue() {\n    const newValue = this._elementRef.nativeElement.value;\n\n    if (this._previousNativeValue !== newValue) {\n      this._previousNativeValue = newValue;\n      this.stateChanges.next();\n    }\n  }\n\n  /** Make sure the input is a supported type. */\n  protected _validateType() {\n    if (MAT_INPUT_INVALID_TYPES.indexOf(this._type) > -1 &&\n      (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw getMatInputUnsupportedTypeError(this._type);\n    }\n  }\n\n  /** Checks whether the input type is one of the types that are never empty. */\n  protected _isNeverEmpty() {\n    return this._neverEmptyInputTypes.indexOf(this._type) > -1;\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    let validity = (this._elementRef.nativeElement as HTMLInputElement).validity;\n    return validity && validity.badInput;\n  }\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  get empty(): boolean {\n    return !this._isNeverEmpty() && !this._elementRef.nativeElement.value && !this._isBadInput() &&\n        !this.autofilled;\n  }\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  get shouldLabelFloat(): boolean {\n    if (this._isNativeSelect) {\n      // For a single-selection `<select>`, the label should float when the selected option has\n      // a non-empty display value. For a `<select multiple>`, the label *always* floats to avoid\n      // overlapping the label with the options.\n      const selectElement = this._elementRef.nativeElement as HTMLSelectElement;\n      const firstOption: HTMLOptionElement | undefined = selectElement.options[0];\n\n      // On most browsers the `selectedIndex` will always be 0, however on IE and Edge it'll be\n      // -1 if the `value` is set to something, that isn't in the list of options, at a later point.\n      return this.focused || selectElement.multiple || !this.empty ||\n             !!(selectElement.selectedIndex > -1 && firstOption && firstOption.label);\n    } else {\n      return this.focused || !this.empty;\n    }\n  }\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  setDescribedByIds(ids: string[]) {\n    if (ids.length) {\n      this._elementRef.nativeElement.setAttribute('aria-describedby', ids.join(' '));\n    } else {\n      this._elementRef.nativeElement.removeAttribute('aria-describedby');\n    }\n  }\n\n  /**\n   * Implemented as part of MatFormFieldControl.\n   * @docs-private\n   */\n  onContainerClick() {\n    // Do not re-focus the input element if the element is already focused. Otherwise it can happen\n    // that someone clicks on a time input and the cursor resets to the \"hours\" field while the\n    // \"minutes\" field was actually clicked. See: https://github.com/angular/components/issues/12849\n    if (!this.focused) {\n      this.focus();\n    }\n  }\n\n  /** Whether the form control is a native select that is displayed inline. */\n  _isInlineSelect(): boolean {\n    const element = this._elementRef.nativeElement as HTMLSelectElement;\n    return this._isNativeSelect && (element.multiple || element.size > 1);\n  }\n\n  static ngAcceptInputType_disabled: BooleanInput;\n  static ngAcceptInputType_readonly: BooleanInput;\n  static ngAcceptInputType_required: BooleanInput;\n\n  // Accept `any` to avoid conflicts with other directives on `<input>` that may\n  // accept different types.\n  static ngAcceptInputType_value: any;\n}\n"]}
|