@ifsworld/granite-components 6.1.0 → 6.1.1

package/esm2020/index.mjs

@@ -34,6 +34,10 @@ export * from './lib/button/button.module';
 export * from './lib/button/button.component';
 export * from './lib/input-field/input-field.module';
 export * from './lib/input-field/input-field.component';
+export * from './lib/chips/chips.module';
+export * from './lib/chips/chip-list.component';
+export * from './lib/chips/chip.component';
+export * from './lib/chips/chip-input';
 export * from './lib/label/label.module';
 export * from './lib/label/label.component';
 // Temporary
@@ -47,4 +51,4 @@ export * from './lib/core/common-behaviors/disabled';
 export * from './lib/core/pipes/pure-pipes.module';
 export * from './lib/core/pipes/title.pipe';
 export * from './lib/core/types';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2dyYW5pdGUtY29tcG9uZW50cy9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyxnREFBZ0QsQ0FBQztBQUUvRCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsMkJBQTJCLENBQUM7QUFFMUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHVDQUF1QyxDQUFDO0FBRXRELGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYywyQkFBMkIsQ0FBQztBQUUxQyxjQUFjLDBDQUEwQyxDQUFDO0FBQ3pELGNBQWMsNkNBQTZDLENBQUM7QUFFNUQsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLDJDQUEyQyxDQUFDO0FBRTFELGNBQWMsMENBQTBDLENBQUM7QUFFekQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLG1DQUFtQyxDQUFDO0FBRWxELGNBQWMseUNBQXlDLENBQUM7QUFFeEQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLCtCQUErQixDQUFDO0FBRTlDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx5Q0FBeUMsQ0FBQztBQUV4RCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNkJBQTZCLENBQUM7QUFFNUMsWUFBWTtBQUNaLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsb0RBQW9ELENBQUM7QUFDbkUsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLG1EQUFtRCxDQUFDO0FBQ2xFLGNBQWMsc0NBQXNDLENBQUM7QUFFckQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsa0JBQWtCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHVpXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvYXJyYW5nZS1ncmlkL2FycmFuZ2UtZ3JpZC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXJyYW5nZS1ncmlkL2FycmFuZ2UtZ3JpZC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYXJyYW5nZS1ncmlkL2FycmFuZ2UtZ3JpZC1pdGVtLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2dyaWQvZ3JpZC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZ3JpZC9ncmlkLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2JhZGdlL2JhZGdlLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9iYWRnZS9iYWRnZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvYmFkZ2UvdGVzdGluZy9iYWRnZS5oYXJuZXNzJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS9tZW51Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tZW51L21lbnUuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21lbnUvbWVudS1kZXNrdG9wLWFuaW1hdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS9tZW51LXRvdWNoLWFuaW1hdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS9tZW51LWl0ZW0uY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21lbnUvbWVudS10cmlnZ2VyLWZvci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS90ZXN0aW5nL21lbnUuaGFybmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tZW51L2RpdmlkZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21lbnUvdGl0bGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21lbnUvbWVudS10b3VjaC1jbG9zZS5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbWVudS9tZW51LXRvdWNoLXRpdGxlLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2ljb24vaWNvbi5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaWNvbi9pY29uLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3RvZ2dsZS1zd2l0Y2gvdG9nZ2xlLXN3aXRjaC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdG9nZ2xlLXN3aXRjaC90b2dnbGUtc3dpdGNoLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3JhZGlvLWJ1dHRvbi9yYWRpby1idXR0b24ubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JhZGlvLWJ1dHRvbi9yYWRpby1idXR0b24uY29tcG9uZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvcmFkaW8tYnV0dG9uL3JhZGlvLWdyb3VwLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NoZWNrYm94L2NoZWNrYm94Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaGVja2JveC9jaGVja2JveC5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jaGVja2JveC9jaGVja2JveC1ncm91cC5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9idXR0b24vYnV0dG9uLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9idXR0b24vYnV0dG9uLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2lucHV0LWZpZWxkL2lucHV0LWZpZWxkLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnB1dC1maWVsZC9pbnB1dC1maWVsZC5jb21wb25lbnQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9sYWJlbC9sYWJlbC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbGFiZWwvbGFiZWwuY29tcG9uZW50JztcblxuLy8gVGVtcG9yYXJ5XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb3JlL2NsaWVudC1lbnZpcm9ubWVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb3JlL2NvcmUubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvcmUvZGV2aWNlcy9jbGllbnQtb3V0cHV0LXRvdWNoLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb3JlL2RldmljZXMvY2xpZW50LW91dHB1dC1kZXNrdG9wLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb3JlL2RldmljZXMvY2xpZW50LWlucHV0LXRvdWNoLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb3JlL2RldmljZXMvY2xpZW50LWlucHV0LWRlc2t0b3AuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvcmUvY29tbW9uLWJlaGF2aW9ycy9kaXNhYmxlZCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvcmUvcGlwZXMvcHVyZS1waXBlcy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29yZS9waXBlcy90aXRsZS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvcmUvdHlwZXMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/chips/chip-input.mjs

@@ -0,0 +1,195 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { BACKSPACE, ENTER, hasModifierKey, TAB } from '@angular/cdk/keycodes';
+import { Directive, ElementRef, EventEmitter, Input, Output, } from '@angular/core';
+import { GraniteChipListComponent } from './chip-list.component';
+import * as i0 from "@angular/core";
+let nextUniqueId = 0;
+export class GraniteChipInputDirective {
+    constructor(_elementRef) {
+        this._elementRef = _elementRef;
+        /** Unique id for the input. */
+        this.id = `granite-chip-list-input-${nextUniqueId++}`;
+        /** The input's placeholder text. */
+        this.placeholder = '';
+        /**
+         * The list of key codes that will trigger a chipEnd event.
+         *
+         * Defaults to `[ENTER]`.
+         */
+        this.graniteChipInputSeparatorKeyCodes = [
+            ENTER,
+        ];
+        this._addOnBlur = true;
+        this._disabled = false;
+        /** Emitted when a chip is to be added. */
+        this.graniteChipInputTokenEnd = new EventEmitter();
+        this.focused = false;
+        this.inputElement = this._elementRef.nativeElement;
+    }
+    /** Register input for chip list */
+    set graniteChipInputFor(value) {
+        if (value) {
+            this._chipList = value;
+            this._chipList.registerInput(this);
+        }
+    }
+    /**
+     * Whether or not the chipEnd event will be emitted when the input is blurred.
+     */
+    get graniteChipInputAddOnBlur() {
+        return this._addOnBlur;
+    }
+    set graniteChipInputAddOnBlur(value) {
+        this._addOnBlur = coerceBooleanProperty(value);
+    }
+    /**
+     * Whether this is a required field, currently we use it only for setting aria-required.
+     */
+    get required() {
+        return this._required;
+    }
+    set required(value) {
+        this._required = coerceBooleanProperty(value);
+    }
+    /** Whether the input is disabled. */
+    get disabled() {
+        return this._disabled || (this._chipList && this._chipList.disabled);
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+    }
+    ngOnChanges() {
+        this._chipList.stateChanges.next();
+    }
+    ngOnDestroy() {
+        this.graniteChipInputTokenEnd.complete();
+    }
+    ngAfterContentInit() {
+        this._focusLastChipOnBackspace = this.empty;
+    }
+    /** Utility method to make host definition/tests more clear. */
+    _keydown(event) {
+        if (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.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {
+                this._chipList._allowFocusEscape();
+            }
+            // To prevent the user from accidentally deleting chips when pressing BACKSPACE continuously,
+            // We focus the last chip on backspace only after the user has released the backspace button,
+            // and the input is empty (see behaviour in _keyup)
+            if (event.keyCode === BACKSPACE && this._focusLastChipOnBackspace) {
+                this._chipList._keyManager.setLastItemActive();
+                event.preventDefault();
+                return;
+            }
+            else {
+                this._focusLastChipOnBackspace = false;
+            }
+        }
+        this._emitChipEnd(event);
+    }
+    /**
+     * Pass events to the keyboard manager. Available here for tests.
+     */
+    _keyup(event) {
+        // Allow user to move focus to chips next time he presses backspace
+        if (!this._focusLastChipOnBackspace &&
+            event.keyCode === BACKSPACE &&
+            this.empty) {
+            this._focusLastChipOnBackspace = true;
+            event.preventDefault();
+        }
+    }
+    /** Checks to see if the blur should emit the (chipEnd) event. */
+    _blur() {
+        if (this.graniteChipInputAddOnBlur) {
+            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();
+    }
+    _focus() {
+        this.focused = true;
+        this._focusLastChipOnBackspace = this.empty;
+        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);
+        }
+        if (!event || this._isSeparatorKey(event)) {
+            this.graniteChipInputTokenEnd.emit({
+                input: this.inputElement,
+                value: this.inputElement.value,
+                chipInput: this,
+            });
+            event?.preventDefault();
+        }
+    }
+    _onInput() {
+        // Let chip list know whenever the value changes.
+        this._chipList.stateChanges.next();
+    }
+    /** Focuses the input (called from parent level). */
+    setFocus(options) {
+        this.inputElement.focus(options);
+    }
+    /** Clears the input */
+    clear() {
+        this.inputElement.value = '';
+        this._focusLastChipOnBackspace = true;
+    }
+    /** Whether the input is empty. */
+    get empty() {
+        return !this.inputElement.value;
+    }
+    /** Checks whether a keycode is one of the configured separators. */
+    _isSeparatorKey(event) {
+        return (!hasModifierKey(event) &&
+            new Set(this.graniteChipInputSeparatorKeyCodes).has(event.keyCode));
+    }
+}
+GraniteChipInputDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GraniteChipInputDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+GraniteChipInputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.11", type: GraniteChipInputDirective, selector: "input[graniteChipInputFor]", inputs: { id: "id", placeholder: "placeholder", graniteChipInputFor: "graniteChipInputFor", graniteChipInputSeparatorKeyCodes: "graniteChipInputSeparatorKeyCodes", graniteChipInputAddOnBlur: "graniteChipInputAddOnBlur", required: "required", disabled: "disabled" }, outputs: { graniteChipInputTokenEnd: "graniteChipInputTokenEnd" }, host: { listeners: { "keydown": "_keydown($event)", "keyup": "_keyup($event)", "blur": "_blur()", "focus": "_focus()", "input": "_onInput()" }, properties: { "id": "id", "attr.disabled": "disabled || null", "attr.placeholder": "placeholder || null", "attr.aria-required": "required || null" }, classAttribute: "granite-chip-input" }, exportAs: ["graniteChipInput", "graniteChipInputFor"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: GraniteChipInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[graniteChipInputFor]',
+                    exportAs: 'graniteChipInput, graniteChipInputFor',
+                    host: {
+                        class: 'granite-chip-input',
+                        '[id]': 'id',
+                        '[attr.disabled]': 'disabled || null',
+                        '[attr.placeholder]': 'placeholder || null',
+                        '[attr.aria-required]': 'required || null',
+                        '(keydown)': '_keydown($event)',
+                        '(keyup)': '_keyup($event)',
+                        '(blur)': '_blur()',
+                        '(focus)': '_focus()',
+                        '(input)': '_onInput()',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { id: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], graniteChipInputFor: [{
+                type: Input
+            }], graniteChipInputSeparatorKeyCodes: [{
+                type: Input
+            }], graniteChipInputAddOnBlur: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], graniteChipInputTokenEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chip-input.js","sourceRoot":"","sources":["../../../../../../libs/granite-components/src/lib/chips/chip-input.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { BACKSPACE, ENTER, hasModifierKey, TAB } from '@angular/cdk/keycodes';\nimport {\n  AfterContentInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n} from '@angular/core';\nimport { GraniteChipListComponent } from './chip-list.component';\n\nexport interface GraniteChipTextControl {\n  /** Unique identifier for the text control. */\n  id: string;\n  /** The text control's placeholder text. */\n  placeholder: string;\n  /** Whether the text control has browser focus. */\n  focused: boolean;\n  /** Whether the text control is empty. */\n  empty: boolean;\n  /** Focuses the text control. */\n  setFocus(options?: FocusOptions): void;\n}\n\n/** Represents an input event on a `graniteChipInput`. */\nexport interface GraniteChipInputEvent {\n  /** The native `<input>` element that the event is being fired for. */\n  input: HTMLInputElement;\n  /** The value of the input. */\n  value: string;\n  /** Reference to the chip input that emitted the event. */\n  chipInput: GraniteChipInputDirective;\n}\n\nlet nextUniqueId = 0;\n\n@Directive({\n  selector: 'input[graniteChipInputFor]',\n  exportAs: 'graniteChipInput, graniteChipInputFor',\n  host: {\n    class: 'granite-chip-input',\n    '[id]': 'id',\n    '[attr.disabled]': 'disabled || null',\n    '[attr.placeholder]': 'placeholder || null',\n    '[attr.aria-required]': 'required || null',\n    '(keydown)': '_keydown($event)',\n    '(keyup)': '_keyup($event)',\n    '(blur)': '_blur()',\n    '(focus)': '_focus()',\n    '(input)': '_onInput()',\n  },\n})\nexport class GraniteChipInputDirective\n  implements GraniteChipTextControl, OnChanges, OnDestroy, AfterContentInit\n{\n  /** Unique id for the input. */\n  @Input() id: string = `granite-chip-list-input-${nextUniqueId++}`;\n\n  /** The input's placeholder text. */\n  @Input() placeholder: string = '';\n\n  /** Register input for chip list */\n  @Input()\n  set graniteChipInputFor(value: GraniteChipListComponent) {\n    if (value) {\n      this._chipList = value;\n      this._chipList.registerInput(this);\n    }\n  }\n\n  /**\n   * The list of key codes that will trigger a chipEnd event.\n   *\n   * Defaults to `[ENTER]`.\n   */\n  @Input()\n  graniteChipInputSeparatorKeyCodes: readonly number[] | ReadonlySet<number> = [\n    ENTER,\n  ] as const;\n\n  /**\n   * Whether or not the chipEnd event will be emitted when the input is blurred.\n   */\n  @Input()\n  get graniteChipInputAddOnBlur(): boolean {\n    return this._addOnBlur;\n  }\n  set graniteChipInputAddOnBlur(value: boolean) {\n    this._addOnBlur = coerceBooleanProperty(value);\n  }\n  _addOnBlur: boolean = true;\n\n  /**\n   * Whether this is a required field, currently we use it only for setting aria-required.\n   */\n  @Input()\n  get required(): boolean {\n    return this._required;\n  }\n  set required(value: boolean) {\n    this._required = coerceBooleanProperty(value);\n  }\n  protected _required: boolean | undefined;\n\n  /** Whether the input is disabled. */\n  @Input()\n  get disabled(): boolean {\n    return this._disabled || (this._chipList && this._chipList.disabled);\n  }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled: boolean = false;\n\n  /** Emitted when a chip is to be added. */\n  @Output() readonly graniteChipInputTokenEnd =\n    new EventEmitter<GraniteChipInputEvent>();\n\n  /** The native input element to which this directive is attached. */\n  readonly inputElement!: HTMLInputElement;\n  _chipList: GraniteChipListComponent;\n  focused: boolean = false;\n  /** Used to prevent focus moving to chips while user is holding backspace */\n  private _focusLastChipOnBackspace: boolean;\n\n  constructor(protected _elementRef: ElementRef<HTMLInputElement>) {\n    this.inputElement = this._elementRef.nativeElement as HTMLInputElement;\n  }\n\n  ngOnChanges(): void {\n    this._chipList.stateChanges.next();\n  }\n\n  ngOnDestroy(): void {\n    this.graniteChipInputTokenEnd.complete();\n  }\n\n  ngAfterContentInit(): void {\n    this._focusLastChipOnBackspace = this.empty;\n  }\n\n  /** Utility method to make host definition/tests more clear. */\n  _keydown(event?: KeyboardEvent): void {\n    if (event) {\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.keyCode === TAB && !hasModifierKey(event, 'shiftKey')) {\n        this._chipList._allowFocusEscape();\n      }\n\n      // To prevent the user from accidentally deleting chips when pressing BACKSPACE continuously,\n      // We focus the last chip on backspace only after the user has released the backspace button,\n      // and the input is empty (see behaviour in _keyup)\n      if (event.keyCode === BACKSPACE && this._focusLastChipOnBackspace) {\n        this._chipList._keyManager.setLastItemActive();\n        event.preventDefault();\n        return;\n      } else {\n        this._focusLastChipOnBackspace = false;\n      }\n    }\n\n    this._emitChipEnd(event);\n  }\n\n  /**\n   * Pass events to the keyboard manager. Available here for tests.\n   */\n  _keyup(event: KeyboardEvent): void {\n    // Allow user to move focus to chips next time he presses backspace\n    if (\n      !this._focusLastChipOnBackspace &&\n      event.keyCode === BACKSPACE &&\n      this.empty\n    ) {\n      this._focusLastChipOnBackspace = true;\n      event.preventDefault();\n    }\n  }\n\n  /** Checks to see if the blur should emit the (chipEnd) event. */\n  _blur(): void {\n    if (this.graniteChipInputAddOnBlur) {\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(): void {\n    this.focused = true;\n    this._focusLastChipOnBackspace = this.empty;\n    this._chipList.stateChanges.next();\n  }\n\n  /** Checks to see if the (chipEnd) event needs to be emitted. */\n  _emitChipEnd(event?: KeyboardEvent): void {\n    if (!this.inputElement.value && !!event) {\n      this._chipList._keydown(event);\n    }\n\n    if (!event || this._isSeparatorKey(event)) {\n      this.graniteChipInputTokenEnd.emit({\n        input: this.inputElement,\n        value: this.inputElement.value,\n        chipInput: this,\n      });\n\n      event?.preventDefault();\n    }\n  }\n\n  _onInput(): void {\n    // Let chip list know whenever the value changes.\n    this._chipList.stateChanges.next();\n  }\n\n  /** Focuses the input (called from parent level). */\n  setFocus(options?: FocusOptions): void {\n    this.inputElement.focus(options);\n  }\n\n  /** Clears the input */\n  clear(): void {\n    this.inputElement.value = '';\n    this._focusLastChipOnBackspace = true;\n  }\n\n  /** Whether the input is empty. */\n  get empty(): boolean {\n    return !this.inputElement.value;\n  }\n\n  /** Checks whether a keycode is one of the configured separators. */\n  private _isSeparatorKey(event: KeyboardEvent): boolean {\n    return (\n      !hasModifierKey(event) &&\n      new Set(this.graniteChipInputSeparatorKeyCodes).has(event.keyCode)\n    );\n  }\n}\n"]}