@angular/material 10.0.0-rc.3 → 10.1.0

package/esm2015/chips/chip-input.js

@@ -16,136 +16,132 @@ let nextUniqueId = 0;
  * Directive that adds chip-specific behaviors to an input element inside `<mat-form-field>`.
  * May be placed inside or outside of an `<mat-chip-list>`.
  */
-let MatChipInput = /** @class */ (() => {
-    class MatChipInput {
-        constructor(_elementRef, _defaultOptions) {
-            this._elementRef = _elementRef;
-            this._defaultOptions = _defaultOptions;
-            /** Whether the control is focused. */
-            this.focused = false;
-            this._addOnBlur = false;
-            /**
-             * The list of key codes that will trigger a chipEnd event.
-             *
-             * Defaults to `[ENTER]`.
-             */
-            this.separatorKeyCodes = this._defaultOptions.separatorKeyCodes;
-            /** Emitted when a chip is to be added. */
-            this.chipEnd = new EventEmitter();
-            /** The input's placeholder text. */
-            this.placeholder = '';
-            /** Unique id for the input. */
-            this.id = `mat-chip-list-input-${nextUniqueId++}`;
-            this._disabled = false;
-            this._inputElement = this._elementRef.nativeElement;
-        }
-        /** Register input for chip list */
-        set chipList(value) {
-            if (value) {
-                this._chipList = value;
-                this._chipList.registerInput(this);
-            }
-        }
+export class MatChipInput {
+    constructor(_elementRef, _defaultOptions) {
+        this._elementRef = _elementRef;
+        this._defaultOptions = _defaultOptions;
+        /** Whether the control is focused. */
+        this.focused = false;
+        this._addOnBlur = false;
         /**
-         * Whether or not the chipEnd event will be emitted when the input is blurred.
+         * The list of key codes that will trigger a chipEnd event.
+         *
+         * Defaults to `[ENTER]`.
          */
-        get addOnBlur() { return this._addOnBlur; }
-        set addOnBlur(value) { this._addOnBlur = coerceBooleanProperty(value); }
-        /** Whether the input is disabled. */
-        get disabled() { return this._disabled || (this._chipList && this._chipList.disabled); }
-        set disabled(value) { this._disabled = coerceBooleanProperty(value); }
-        /** Whether the input is empty. */
-        get empty() { return !this._inputElement.value; }
-        ngOnChanges() {
-            this._chipList.stateChanges.next();
-        }
-        /** Utility method to make host definition/tests more clear. */
-        _keydown(event) {
-            // Allow the user's focus to escape when they're tabbing forward. Note that we don't
-            // want to do this when going backwards, because focus should go back to the first chip.
-            if (event && event.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {
-                this._chipList._allowFocusEscape();
-            }
-            this._emitChipEnd(event);
-        }
-        /** Checks to see if the blur should emit the (chipEnd) event. */
-        _blur() {
-            if (this.addOnBlur) {
-                this._emitChipEnd();
-            }
-            this.focused = false;
-            // Blur the chip list if it is not focused
-            if (!this._chipList.focused) {
-                this._chipList._blur();
-            }
-            this._chipList.stateChanges.next();
+        this.separatorKeyCodes = this._defaultOptions.separatorKeyCodes;
+        /** Emitted when a chip is to be added. */
+        this.chipEnd = new EventEmitter();
+        /** The input's placeholder text. */
+        this.placeholder = '';
+        /** Unique id for the input. */
+        this.id = `mat-chip-list-input-${nextUniqueId++}`;
+        this._disabled = false;
+        this._inputElement = this._elementRef.nativeElement;
+    }
+    /** Register input for chip list */
+    set chipList(value) {
+        if (value) {
+            this._chipList = value;
+            this._chipList.registerInput(this);
         }
-        _focus() {
-            this.focused = true;
-            this._chipList.stateChanges.next();
+    }
+    /**
+     * Whether or not the chipEnd event will be emitted when the input is blurred.
+     */
+    get addOnBlur() { return this._addOnBlur; }
+    set addOnBlur(value) { this._addOnBlur = coerceBooleanProperty(value); }
+    /** Whether the input is disabled. */
+    get disabled() { return this._disabled || (this._chipList && this._chipList.disabled); }
+    set disabled(value) { this._disabled = coerceBooleanProperty(value); }
+    /** Whether the input is empty. */
+    get empty() { return !this._inputElement.value; }
+    ngOnChanges() {
+        this._chipList.stateChanges.next();
+    }
+    /** Utility method to make host definition/tests more clear. */
+    _keydown(event) {
+        // Allow the user's focus to escape when they're tabbing forward. Note that we don't
+        // want to do this when going backwards, because focus should go back to the first chip.
+        if (event && event.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {
+            this._chipList._allowFocusEscape();
         }
-        /** Checks to see if the (chipEnd) event needs to be emitted. */
-        _emitChipEnd(event) {
-            if (!this._inputElement.value && !!event) {
-                this._chipList._keydown(event);
-            }
-            if (!event || this._isSeparatorKey(event)) {
-                this.chipEnd.emit({ input: this._inputElement, value: this._inputElement.value });
-                if (event) {
-                    event.preventDefault();
-                }
-            }
+        this._emitChipEnd(event);
+    }
+    /** Checks to see if the blur should emit the (chipEnd) event. */
+    _blur() {
+        if (this.addOnBlur) {
+            this._emitChipEnd();
         }
-        _onInput() {
-            // Let chip list know whenever the value changes.
-            this._chipList.stateChanges.next();
+        this.focused = false;
+        // Blur the chip list if it is not focused
+        if (!this._chipList.focused) {
+            this._chipList._blur();
         }
-        /** Focuses the input. */
-        focus(options) {
-            this._inputElement.focus(options);
+        this._chipList.stateChanges.next();
+    }
+    _focus() {
+        this.focused = true;
+        this._chipList.stateChanges.next();
+    }
+    /** Checks to see if the (chipEnd) event needs to be emitted. */
+    _emitChipEnd(event) {
+        if (!this._inputElement.value && !!event) {
+            this._chipList._keydown(event);
         }
-        /** Checks whether a keycode is one of the configured separators. */
-        _isSeparatorKey(event) {
-            if (hasModifierKey(event)) {
-                return false;
+        if (!event || this._isSeparatorKey(event)) {
+            this.chipEnd.emit({ input: this._inputElement, value: this._inputElement.value });
+            if (event) {
+                event.preventDefault();
             }
-            const separators = this.separatorKeyCodes;
-            const keyCode = event.keyCode;
-            return Array.isArray(separators) ? separators.indexOf(keyCode) > -1 : separators.has(keyCode);
         }
     }
-    MatChipInput.decorators = [
-        { type: Directive, args: [{
-                    selector: 'input[matChipInputFor]',
-                    exportAs: 'matChipInput, matChipInputFor',
-                    host: {
-                        'class': 'mat-chip-input mat-input-element',
-                        '(keydown)': '_keydown($event)',
-                        '(blur)': '_blur()',
-                        '(focus)': '_focus()',
-                        '(input)': '_onInput()',
-                        '[id]': 'id',
-                        '[attr.disabled]': 'disabled || null',
-                        '[attr.placeholder]': 'placeholder || null',
-                        '[attr.aria-invalid]': '_chipList && _chipList.ngControl ? _chipList.ngControl.invalid : null',
-                        '[attr.aria-required]': '_chipList && _chipList.required || null',
-                    }
-                },] }
-    ];
-    MatChipInput.ctorParameters = () => [
-        { type: ElementRef },
-        { type: undefined, decorators: [{ type: Inject, args: [MAT_CHIPS_DEFAULT_OPTIONS,] }] }
-    ];
-    MatChipInput.propDecorators = {
-        chipList: [{ type: Input, args: ['matChipInputFor',] }],
-        addOnBlur: [{ type: Input, args: ['matChipInputAddOnBlur',] }],
-        separatorKeyCodes: [{ type: Input, args: ['matChipInputSeparatorKeyCodes',] }],
-        chipEnd: [{ type: Output, args: ['matChipInputTokenEnd',] }],
-        placeholder: [{ type: Input }],
-        id: [{ type: Input }],
-        disabled: [{ type: Input }]
-    };
-    return MatChipInput;
-})();
-export { MatChipInput };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chip-input.js","sourceRoot":"","sources":["../../../../../../src/material/chips/chip-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 {Directive, ElementRef, EventEmitter, Inject, Input, OnChanges, Output} from '@angular/core';\nimport {hasModifierKey, TAB} from '@angular/cdk/keycodes';\nimport {MAT_CHIPS_DEFAULT_OPTIONS, MatChipsDefaultOptions} from './chip-default-options';\nimport {MatChipList} from './chip-list';\nimport {MatChipTextControl} from './chip-text-control';\n\n\n/** Represents an input event on a `matChipInput`. */\nexport interface MatChipInputEvent {\n  /** The native `<input>` element that the event is being fired for. */\n  input: HTMLInputElement;\n\n  /** The value of the input. */\n  value: string;\n}\n\n// Increasing integer for generating unique ids.\nlet nextUniqueId = 0;\n\n/**\n * Directive that adds chip-specific behaviors to an input element inside `<mat-form-field>`.\n * May be placed inside or outside of an `<mat-chip-list>`.\n */\n@Directive({\n  selector: 'input[matChipInputFor]',\n  exportAs: 'matChipInput, matChipInputFor',\n  host: {\n    'class': 'mat-chip-input mat-input-element',\n    '(keydown)': '_keydown($event)',\n    '(blur)': '_blur()',\n    '(focus)': '_focus()',\n    '(input)': '_onInput()',\n    '[id]': 'id',\n    '[attr.disabled]': 'disabled || null',\n    '[attr.placeholder]': 'placeholder || null',\n    '[attr.aria-invalid]': '_chipList && _chipList.ngControl ? _chipList.ngControl.invalid : null',\n    '[attr.aria-required]': '_chipList && _chipList.required || null',\n  }\n})\nexport class MatChipInput implements MatChipTextControl, OnChanges {\n  /** Whether the control is focused. */\n  focused: boolean = false;\n  _chipList: MatChipList;\n\n  /** Register input for chip list */\n  @Input('matChipInputFor')\n  set chipList(value: MatChipList) {\n    if (value) {\n      this._chipList = value;\n      this._chipList.registerInput(this);\n    }\n  }\n\n  /**\n   * Whether or not the chipEnd event will be emitted when the input is blurred.\n   */\n  @Input('matChipInputAddOnBlur')\n  get addOnBlur(): boolean { return this._addOnBlur; }\n  set addOnBlur(value: boolean) { this._addOnBlur = coerceBooleanProperty(value); }\n  _addOnBlur: boolean = false;\n\n  /**\n   * The list of key codes that will trigger a chipEnd event.\n   *\n   * Defaults to `[ENTER]`.\n   */\n  @Input('matChipInputSeparatorKeyCodes')\n  separatorKeyCodes: number[] | Set<number> = this._defaultOptions.separatorKeyCodes;\n\n  /** Emitted when a chip is to be added. */\n  @Output('matChipInputTokenEnd')\n  chipEnd: EventEmitter<MatChipInputEvent> = new EventEmitter<MatChipInputEvent>();\n\n  /** The input's placeholder text. */\n  @Input() placeholder: string = '';\n\n  /** Unique id for the input. */\n  @Input() id: string = `mat-chip-list-input-${nextUniqueId++}`;\n\n  /** Whether the input is disabled. */\n  @Input()\n  get disabled(): boolean { return this._disabled || (this._chipList && this._chipList.disabled); }\n  set disabled(value: boolean) { this._disabled = coerceBooleanProperty(value); }\n  private _disabled: boolean = false;\n\n  /** Whether the input is empty. */\n  get empty(): boolean { return !this._inputElement.value; }\n\n  /** The native input element to which this directive is attached. */\n  protected _inputElement: HTMLInputElement;\n\n  constructor(\n    protected _elementRef: ElementRef<HTMLInputElement>,\n    @Inject(MAT_CHIPS_DEFAULT_OPTIONS) private _defaultOptions: MatChipsDefaultOptions) {\n    this._inputElement = this._elementRef.nativeElement as HTMLInputElement;\n  }\n\n  ngOnChanges() {\n    this._chipList.stateChanges.next();\n  }\n\n  /** Utility method to make host definition/tests more clear. */\n  _keydown(event?: KeyboardEvent) {\n    // Allow the user's focus to escape when they're tabbing forward. Note that we don't\n    // want to do this when going backwards, because focus should go back to the first chip.\n    if (event && event.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {\n      this._chipList._allowFocusEscape();\n    }\n\n    this._emitChipEnd(event);\n  }\n\n  /** Checks to see if the blur should emit the (chipEnd) event. */\n  _blur() {\n    if (this.addOnBlur) {\n      this._emitChipEnd();\n    }\n    this.focused = false;\n    // Blur the chip list if it is not focused\n    if (!this._chipList.focused) {\n      this._chipList._blur();\n    }\n    this._chipList.stateChanges.next();\n  }\n\n  _focus() {\n    this.focused = true;\n    this._chipList.stateChanges.next();\n  }\n\n  /** Checks to see if the (chipEnd) event needs to be emitted. */\n  _emitChipEnd(event?: KeyboardEvent) {\n    if (!this._inputElement.value && !!event) {\n      this._chipList._keydown(event);\n    }\n    if (!event || this._isSeparatorKey(event)) {\n      this.chipEnd.emit({ input: this._inputElement, value: this._inputElement.value });\n\n      if (event) {\n        event.preventDefault();\n      }\n    }\n  }\n\n  _onInput() {\n    // Let chip list know whenever the value changes.\n    this._chipList.stateChanges.next();\n  }\n\n  /** Focuses the input. */\n  focus(options?: FocusOptions): void {\n    this._inputElement.focus(options);\n  }\n\n  /** Checks whether a keycode is one of the configured separators. */\n  private _isSeparatorKey(event: KeyboardEvent) {\n    if (hasModifierKey(event)) {\n      return false;\n    }\n\n    const separators = this.separatorKeyCodes;\n    const keyCode = event.keyCode;\n    return Array.isArray(separators) ? separators.indexOf(keyCode) > -1 : separators.has(keyCode);\n  }\n\n  static ngAcceptInputType_addOnBlur: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}
+    _onInput() {
+        // Let chip list know whenever the value changes.
+        this._chipList.stateChanges.next();
+    }
+    /** Focuses the input. */
+    focus(options) {
+        this._inputElement.focus(options);
+    }
+    /** Checks whether a keycode is one of the configured separators. */
+    _isSeparatorKey(event) {
+        if (hasModifierKey(event)) {
+            return false;
+        }
+        const separators = this.separatorKeyCodes;
+        const keyCode = event.keyCode;
+        return Array.isArray(separators) ? separators.indexOf(keyCode) > -1 : separators.has(keyCode);
+    }
+}
+MatChipInput.decorators = [
+    { type: Directive, args: [{
+                selector: 'input[matChipInputFor]',
+                exportAs: 'matChipInput, matChipInputFor',
+                host: {
+                    'class': 'mat-chip-input mat-input-element',
+                    '(keydown)': '_keydown($event)',
+                    '(blur)': '_blur()',
+                    '(focus)': '_focus()',
+                    '(input)': '_onInput()',
+                    '[id]': 'id',
+                    '[attr.disabled]': 'disabled || null',
+                    '[attr.placeholder]': 'placeholder || null',
+                    '[attr.aria-invalid]': '_chipList && _chipList.ngControl ? _chipList.ngControl.invalid : null',
+                    '[attr.aria-required]': '_chipList && _chipList.required || null',
+                }
+            },] }
+];
+MatChipInput.ctorParameters = () => [
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Inject, args: [MAT_CHIPS_DEFAULT_OPTIONS,] }] }
+];
+MatChipInput.propDecorators = {
+    chipList: [{ type: Input, args: ['matChipInputFor',] }],
+    addOnBlur: [{ type: Input, args: ['matChipInputAddOnBlur',] }],
+    separatorKeyCodes: [{ type: Input, args: ['matChipInputSeparatorKeyCodes',] }],
+    chipEnd: [{ type: Output, args: ['matChipInputTokenEnd',] }],
+    placeholder: [{ type: Input }],
+    id: [{ type: Input }],
+    disabled: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chip-input.js","sourceRoot":"","sources":["../../../../../../src/material/chips/chip-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 {Directive, ElementRef, EventEmitter, Inject, Input, OnChanges, Output} from '@angular/core';\nimport {hasModifierKey, TAB} from '@angular/cdk/keycodes';\nimport {MAT_CHIPS_DEFAULT_OPTIONS, MatChipsDefaultOptions} from './chip-default-options';\nimport {MatChipList} from './chip-list';\nimport {MatChipTextControl} from './chip-text-control';\n\n\n/** Represents an input event on a `matChipInput`. */\nexport interface MatChipInputEvent {\n  /** The native `<input>` element that the event is being fired for. */\n  input: HTMLInputElement;\n\n  /** The value of the input. */\n  value: string;\n}\n\n// Increasing integer for generating unique ids.\nlet nextUniqueId = 0;\n\n/**\n * Directive that adds chip-specific behaviors to an input element inside `<mat-form-field>`.\n * May be placed inside or outside of an `<mat-chip-list>`.\n */\n@Directive({\n  selector: 'input[matChipInputFor]',\n  exportAs: 'matChipInput, matChipInputFor',\n  host: {\n    'class': 'mat-chip-input mat-input-element',\n    '(keydown)': '_keydown($event)',\n    '(blur)': '_blur()',\n    '(focus)': '_focus()',\n    '(input)': '_onInput()',\n    '[id]': 'id',\n    '[attr.disabled]': 'disabled || null',\n    '[attr.placeholder]': 'placeholder || null',\n    '[attr.aria-invalid]': '_chipList && _chipList.ngControl ? _chipList.ngControl.invalid : null',\n    '[attr.aria-required]': '_chipList && _chipList.required || null',\n  }\n})\nexport class MatChipInput implements MatChipTextControl, OnChanges {\n  /** Whether the control is focused. */\n  focused: boolean = false;\n  _chipList: MatChipList;\n\n  /** Register input for chip list */\n  @Input('matChipInputFor')\n  set chipList(value: MatChipList) {\n    if (value) {\n      this._chipList = value;\n      this._chipList.registerInput(this);\n    }\n  }\n\n  /**\n   * Whether or not the chipEnd event will be emitted when the input is blurred.\n   */\n  @Input('matChipInputAddOnBlur')\n  get addOnBlur(): boolean { return this._addOnBlur; }\n  set addOnBlur(value: boolean) { this._addOnBlur = coerceBooleanProperty(value); }\n  _addOnBlur: boolean = false;\n\n  /**\n   * The list of key codes that will trigger a chipEnd event.\n   *\n   * Defaults to `[ENTER]`.\n   */\n  @Input('matChipInputSeparatorKeyCodes')\n  separatorKeyCodes: number[] | Set<number> = this._defaultOptions.separatorKeyCodes;\n\n  /** Emitted when a chip is to be added. */\n  @Output('matChipInputTokenEnd')\n  chipEnd: EventEmitter<MatChipInputEvent> = new EventEmitter<MatChipInputEvent>();\n\n  /** The input's placeholder text. */\n  @Input() placeholder: string = '';\n\n  /** Unique id for the input. */\n  @Input() id: string = `mat-chip-list-input-${nextUniqueId++}`;\n\n  /** Whether the input is disabled. */\n  @Input()\n  get disabled(): boolean { return this._disabled || (this._chipList && this._chipList.disabled); }\n  set disabled(value: boolean) { this._disabled = coerceBooleanProperty(value); }\n  private _disabled: boolean = false;\n\n  /** Whether the input is empty. */\n  get empty(): boolean { return !this._inputElement.value; }\n\n  /** The native input element to which this directive is attached. */\n  protected _inputElement: HTMLInputElement;\n\n  constructor(\n    protected _elementRef: ElementRef<HTMLInputElement>,\n    @Inject(MAT_CHIPS_DEFAULT_OPTIONS) private _defaultOptions: MatChipsDefaultOptions) {\n    this._inputElement = this._elementRef.nativeElement as HTMLInputElement;\n  }\n\n  ngOnChanges() {\n    this._chipList.stateChanges.next();\n  }\n\n  /** Utility method to make host definition/tests more clear. */\n  _keydown(event?: KeyboardEvent) {\n    // Allow the user's focus to escape when they're tabbing forward. Note that we don't\n    // want to do this when going backwards, because focus should go back to the first chip.\n    if (event && event.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {\n      this._chipList._allowFocusEscape();\n    }\n\n    this._emitChipEnd(event);\n  }\n\n  /** Checks to see if the blur should emit the (chipEnd) event. */\n  _blur() {\n    if (this.addOnBlur) {\n      this._emitChipEnd();\n    }\n    this.focused = false;\n    // Blur the chip list if it is not focused\n    if (!this._chipList.focused) {\n      this._chipList._blur();\n    }\n    this._chipList.stateChanges.next();\n  }\n\n  _focus() {\n    this.focused = true;\n    this._chipList.stateChanges.next();\n  }\n\n  /** Checks to see if the (chipEnd) event needs to be emitted. */\n  _emitChipEnd(event?: KeyboardEvent) {\n    if (!this._inputElement.value && !!event) {\n      this._chipList._keydown(event);\n    }\n    if (!event || this._isSeparatorKey(event)) {\n      this.chipEnd.emit({ input: this._inputElement, value: this._inputElement.value });\n\n      if (event) {\n        event.preventDefault();\n      }\n    }\n  }\n\n  _onInput() {\n    // Let chip list know whenever the value changes.\n    this._chipList.stateChanges.next();\n  }\n\n  /** Focuses the input. */\n  focus(options?: FocusOptions): void {\n    this._inputElement.focus(options);\n  }\n\n  /** Checks whether a keycode is one of the configured separators. */\n  private _isSeparatorKey(event: KeyboardEvent) {\n    if (hasModifierKey(event)) {\n      return false;\n    }\n\n    const separators = this.separatorKeyCodes;\n    const keyCode = event.keyCode;\n    return Array.isArray(separators) ? separators.indexOf(keyCode) > -1 : separators.has(keyCode);\n  }\n\n  static ngAcceptInputType_addOnBlur: BooleanInput;\n  static ngAcceptInputType_disabled: BooleanInput;\n}\n"]}