@vaadin/field-base 22.0.0-alpha1 → 22.0.0-alpha10

package/src/input-control-mixin.js

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { KeyboardMixin } from '@vaadin/component-base/src/keyboard-mixin.js';
+import { DelegateFocusMixin } from './delegate-focus-mixin.js';
+import { FieldMixin } from './field-mixin.js';
+import { InputConstraintsMixin } from './input-constraints-mixin.js';
+
+/**
+ * A mixin to provide shared logic for the editable form input controls.
+ *
+ * @polymerMixin
+ * @mixes DelegateFocusMixin
+ * @mixes FieldMixin
+ * @mixes InputConstraintsMixin
+ * @mixes KeyboardMixin
+ */
+export const InputControlMixin = (superclass) =>
+  class InputControlMixinClass extends DelegateFocusMixin(
+    InputConstraintsMixin(FieldMixin(KeyboardMixin(superclass)))
+  ) {
+    static get properties() {
+      return {
+        /**
+         * If true, the input text gets fully selected when the field is focused using click or touch / tap.
+         */
+        autoselect: {
+          type: Boolean,
+          value: false
+        },
+
+        /**
+         * Set to true to display the clear icon which clears the input.
+         * @attr {boolean} clear-button-visible
+         */
+        clearButtonVisible: {
+          type: Boolean,
+          reflectToAttribute: true,
+          value: false
+        },
+
+        /**
+         * The name of this field.
+         */
+        name: {
+          type: String,
+          reflectToAttribute: true
+        },
+
+        /**
+         * A hint to the user of what can be entered in the field.
+         */
+        placeholder: {
+          type: String,
+          reflectToAttribute: true
+        },
+
+        /**
+         * When present, it specifies that the field is read-only.
+         */
+        readonly: {
+          type: Boolean,
+          value: false,
+          reflectToAttribute: true
+        },
+
+        /**
+         * The text usually displayed in a tooltip popup when the mouse is over the field.
+         */
+        title: {
+          type: String,
+          reflectToAttribute: true
+        }
+      };
+    }
+
+    static get delegateAttrs() {
+      return [...super.delegateAttrs, 'name', 'type', 'placeholder', 'readonly', 'invalid', 'title'];
+    }
+
+    /**
+     * Any element extending this mixin is required to implement this getter.
+     * It returns the reference to the clear button element.
+     * @protected
+     * @return {Element | null | undefined}
+     */
+    get clearElement() {
+      console.warn(`Please implement the 'clearElement' property in <${this.localName}>`);
+      return null;
+    }
+
+    /** @protected */
+    ready() {
+      super.ready();
+
+      if (this.clearElement) {
+        this.clearElement.addEventListener('click', (e) => this._onClearButtonClick(e));
+      }
+    }
+
+    /**
+     * @param {Event} event
+     * @protected
+     */
+    _onClearButtonClick(event) {
+      event.preventDefault();
+      this.inputElement.focus();
+      this.clear();
+      this.inputElement.dispatchEvent(new Event('input', { bubbles: true, composed: true }));
+      this.inputElement.dispatchEvent(new Event('change', { bubbles: true }));
+    }
+
+    /**
+     * Override an event listener from `DelegateFocusMixin`.
+     * @param {FocusEvent} event
+     * @protected
+     * @override
+     */
+    _onFocus(event) {
+      super._onFocus(event);
+
+      if (this.autoselect && this.inputElement) {
+        this.inputElement.select();
+      }
+    }
+
+    /**
+     * Override an event listener inherited from `KeydownMixin` to clear on Esc.
+     * Components that extend this mixin can prevent this behavior by overriding
+     * this method without calling `super._onKeyDown` to provide custom logic.
+     * @param {KeyboardEvent} event
+     * @protected
+     * @override
+     */
+    _onKeyDown(event) {
+      super._onKeyDown(event);
+
+      if (event.key === 'Escape' && this.clearButtonVisible) {
+        const dispatchChange = !!this.value;
+        this.clear();
+        dispatchChange && this.inputElement.dispatchEvent(new Event('change', { bubbles: true }));
+      }
+    }
+
+    /**
+     * Override an event listener inherited from `InputMixin`
+     * to capture native `change` event and make sure that
+     * a new one is dispatched after validation runs.
+     * @param {Event} event
+     * @protected
+     * @override
+     */
+    _onChange(event) {
+      event.stopPropagation();
+
+      this.validate();
+
+      this.dispatchEvent(
+        new CustomEvent('change', {
+          detail: {
+            sourceEvent: event
+          },
+          bubbles: event.bubbles,
+          cancelable: event.cancelable
+        })
+      );
+    }
+  };

package/src/input-controller.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { SlotController } from './slot-controller.js';
+
+/**
+ * A controller to create and initialize slotted `<input>` element.
+ */
+export class InputController implements SlotController {}

package/src/input-controller.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { SlotController } from './slot-controller.js';
+
+/**
+ * A controller to create and initialize slotted `<input>` element.
+ */
+export class InputController extends SlotController {
+  constructor(host, callback) {
+    super(host, [
+      'input',
+      () => document.createElement('input'),
+      (host, node) => {
+        if (host.value) {
+          node.setAttribute('value', host.value);
+        }
+        if (host.type) {
+          node.setAttribute('type', host.type);
+        }
+
+        // Ensure every instance has unique ID
+        const uniqueId = (InputController._uniqueInputId = 1 + InputController._uniqueInputId || 0);
+        host._inputId = `${host.localName}-${uniqueId}`;
+        node.id = host._inputId;
+
+        if (typeof callback == 'function') {
+          callback(node);
+        }
+      }
+    ]);
+  }
+}

package/src/input-field-mixin.d.ts

@@ -3,10 +3,7 @@
  * Copyright (c) 2021 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { ClearButtonMixin } from './clear-button-mixin.js';
-import { DelegateFocusMixin } from './delegate-focus-mixin.js';
-import { FieldAriaMixin } from './field-aria-mixin.js';
-import { InputPropsMixin } from './input-props-mixin.js';
+import { InputControlMixin } from './input-control-mixin.js';
 
 /**
  * A mixin to provide logic for vaadin-text-field and related components.
@@ -17,9 +14,7 @@ interface InputFieldMixinConstructor {
   new (...args: any[]): InputFieldMixin;
 }
 
-interface InputFieldMixin extends ClearButtonMixin, DelegateFocusMixin, FieldAriaMixin, InputPropsMixin {
-  readonly inputElement: HTMLElement | undefined;
-
+interface InputFieldMixin extends InputControlMixin {
   /**
    * Whether the value of the control can be automatically completed by the browser.
    * List of available options at:
@@ -46,21 +41,6 @@ interface InputFieldMixin extends ClearButtonMixin, DelegateFocusMixin, FieldAri
    * none: No capitalization.
    */
   autocapitalize: 'on' | 'off' | 'none' | 'characters' | 'words' | 'sentences' | undefined;
-
-  /**
-   * Specify that the value should be automatically selected when the field gains focus.
-   */
-  autoselect: boolean;
-
-  /**
-   * The value of the field.
-   */
-  value: string;
-
-  /**
-   * Returns true if the current input value satisfies all constraints (if any).
-   */
-  checkValidity(): boolean;
 }
 
 export { InputFieldMixin, InputFieldMixinConstructor };

package/src/input-field-mixin.js

@@ -3,16 +3,16 @@
  * Copyright (c) 2021 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { Debouncer } from '@polymer/polymer/lib/utils/debounce.js';
-import { animationFrame } from '@polymer/polymer/lib/utils/async.js';
-import { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';
-import { ClearButtonMixin } from './clear-button-mixin.js';
-import { DelegateFocusMixin } from './delegate-focus-mixin.js';
-import { FieldAriaMixin } from './field-aria-mixin.js';
-import { InputPropsMixin } from './input-props-mixin.js';
+import { InputControlMixin } from './input-control-mixin.js';
 
-const InputFieldMixinImplementation = (superclass) =>
-  class InputFieldMixinClass extends ClearButtonMixin(FieldAriaMixin(InputPropsMixin(DelegateFocusMixin(superclass)))) {
+/**
+ * A mixin to provide logic for vaadin-text-field and related components.
+ *
+ * @polymerMixin
+ * @mixes InputControlMixin
+ */
+export const InputFieldMixin = (superclass) =>
+  class InputFieldMixinClass extends InputControlMixin(superclass) {
     static get properties() {
       return {
         /**
@@ -49,112 +49,56 @@ const InputFieldMixinImplementation = (superclass) =>
         },
 
         /**
-         * Specify that the value should be automatically selected when the field gains focus.
+         * A pattern matched against individual characters the user inputs.
+         * When set, the field will prevent:
+         * - `keyDown` events if the entered key doesn't match `/^_enabledCharPattern$/`
+         * - `paste` events if the pasted text doesn't match `/^_enabledCharPattern*$/`
+         * - `drop` events if the dropped text doesn't match `/^_enabledCharPattern*$/`
+         *
+         * For example, to enable entering only numbers and minus signs,
+         * `_enabledCharPattern = "[\\d-]"`
+         * @protected
          */
-        autoselect: {
-          type: Boolean,
-          value: false
-        },
-
-        /**
-         * The value of the field.
-         */
-        value: {
+        _enabledCharPattern: {
           type: String,
-          value: '',
-          observer: '_valueChanged',
-          notify: true
+          observer: '_enabledCharPatternChanged'
         }
       };
     }
 
-    static get hostProps() {
-      return [...super.hostProps, 'autocapitalize', 'autocomplete', 'autocorrect'];
-    }
-
-    static get observers() {
-      return ['__observeOffsetHeight(errorMessage, invalid, label, helperText)'];
-    }
-
-    /**
-     * Element used by `FieldAriaMixin` to set ARIA attributes.
-     * @protected
-     */
-    get _ariaTarget() {
-      return this._inputNode;
-    }
-
-    /**
-     * Element used by `DelegatesFocusMixin` to handle focus.
-     * @return {!HTMLInputElement}
-     */
-    get focusElement() {
-      return this._inputNode;
+    static get delegateAttrs() {
+      return [...super.delegateAttrs, 'autocapitalize', 'autocomplete', 'autocorrect'];
     }
 
     constructor() {
       super();
 
-      this._boundOnInput = this._onInput.bind(this);
-      this._boundOnBlur = this._onBlur.bind(this);
-      this._boundOnFocus = this._onFocus.bind(this);
+      this._boundOnPaste = this._onPaste.bind(this);
+      this._boundOnDrop = this._onDrop.bind(this);
+      this._boundOnBeforeInput = this._onBeforeInput.bind(this);
     }
 
-    /** @protected */
-    connectedCallback() {
-      super.connectedCallback();
-
-      if (this._inputNode) {
-        this._addInputListeners(this._inputNode);
+    /**
+     * @param {HTMLElement} input
+     * @protected
+     * @override
+     */
+    _inputElementChanged(input) {
+      super._inputElementChanged(input);
 
+      if (input) {
         // Discard value set on the custom slotted input.
-        if (this._inputNode.value !== this.value) {
+        if (input.value && input.value !== this.value) {
           console.warn(`Please define value on the <${this.localName}> component!`);
-          this._inputNode.value = '';
+          input.value = '';
         }
 
         if (this.value) {
-          this._inputNode.value = this.value;
-          this.validate();
+          input.value = this.value;
         }
       }
     }
 
-    /** @protected */
-    disconnectedCallback() {
-      super.disconnectedCallback();
-
-      if (this._inputNode) {
-        this._removeInputListeners(this._inputNode);
-      }
-    }
-
-    /** @protected */
-    ready() {
-      super.ready();
-
-      // Lumo theme defines a max-height transition for the "error-message"
-      // part on invalid state change.
-      const errorPart = this.shadowRoot.querySelector('[part="error-message"]');
-      if (errorPart) {
-        errorPart.addEventListener('transitionend', () => {
-          this.__observeOffsetHeight();
-        });
-      }
-    }
-
-    /**
-     * Returns true if the current input value satisfies all constraints (if any).
-     * @return {boolean}
-     */
-    checkValidity() {
-      if (this.required) {
-        return this._inputNode ? this._inputNode.checkValidity() : undefined;
-      } else {
-        return !this.invalid;
-      }
-    }
-
     // Workaround for https://github.com/Polymer/polymer/issues/5259
     get __data() {
       return this.__dataValue || {};
@@ -165,117 +109,122 @@ const InputFieldMixinImplementation = (superclass) =>
     }
 
     /**
-     * @param {HTMLElement} node
+     * Override an event listener from `DelegateFocusMixin`.
+     * @param {FocusEvent} event
      * @protected
+     * @override
      */
-    _addInputListeners(node) {
-      node.addEventListener('input', this._boundOnInput);
-      node.addEventListener('blur', this._boundOnBlur);
-      node.addEventListener('focus', this._boundOnFocus);
+    _onBlur(event) {
+      super._onBlur(event);
+
+      this.validate();
     }
 
     /**
-     * @param {HTMLElement} node
+     * Override a method from `InputMixin` to validate the field
+     * when a new value is set programmatically.
+     * @param {string} value
      * @protected
+     * @override
      */
-    _removeInputListeners(node) {
-      node.removeEventListener('input', this._boundOnInput);
-      node.removeEventListener('blur', this._boundOnBlur);
-      node.removeEventListener('focus', this._boundOnFocus);
-    }
+    _forwardInputValue(value) {
+      super._forwardInputValue(value);
 
-    /** @private */
-    _onFocus() {
-      if (this.autoselect && this._inputNode) {
-        this._inputNode.select();
+      if (this.invalid) {
+        this.validate();
       }
     }
 
-    /** @private */
-    _onBlur() {
-      this.validate();
+    /**
+     * Override a method from `InputMixin`.
+     * @param {!HTMLElement} input
+     * @protected
+     * @override
+     */
+    _addInputListeners(input) {
+      super._addInputListeners(input);
+
+      input.addEventListener('paste', this._boundOnPaste);
+      input.addEventListener('drop', this._boundOnDrop);
+      input.addEventListener('beforeinput', this._boundOnBeforeInput);
     }
 
     /**
-     * @param {Event} event
+     * Override a method from `InputMixin`.
+     * @param {!HTMLElement} input
      * @protected
+     * @override
      */
-    _onInput(event) {
-      // Ignore manual clear button events
-      this.__userInput = event.isTrusted;
-      this.value = event.target.value;
-      this.__userInput = false;
+    _removeInputListeners(input) {
+      super._removeInputListeners(input);
+
+      input.removeEventListener('paste', this._boundOnPaste);
+      input.removeEventListener('drop', this._boundOnDrop);
+      input.removeEventListener('beforeinput', this._boundOnBeforeInput);
     }
 
     /**
-     * Dispatch an event if a specific size measurement property has changed.
-     * Supporting multiple properties here is needed for `vaadin-text-area`.
+     * Override an event listener from `ClearButtonMixin`
+     * to avoid adding a separate listener.
+     * @param {!KeyboardEvent} event
      * @protected
+     * @override
      */
-    _dispatchIronResizeEventIfNeeded(prop, value) {
-      const oldSize = '__old' + prop;
-      if (this[oldSize] !== undefined && this[oldSize] !== value) {
-        this.dispatchEvent(new CustomEvent('iron-resize', { bubbles: true, composed: true }));
+    _onKeyDown(event) {
+      if (this._enabledCharPattern && !this.__shouldAcceptKey(event)) {
+        event.preventDefault();
       }
 
-      this[oldSize] = value;
+      super._onKeyDown(event);
     }
 
     /** @private */
-    __observeOffsetHeight() {
-      this.__observeOffsetHeightDebouncer = Debouncer.debounce(
-        this.__observeOffsetHeightDebouncer,
-        animationFrame,
-        () => {
-          this._dispatchIronResizeEventIfNeeded('Height', this.offsetHeight);
-        }
+    __shouldAcceptKey(event) {
+      return (
+        event.metaKey ||
+        event.ctrlKey ||
+        !event.key || // allow typing anything if event.key is not supported
+        event.key.length !== 1 || // allow "Backspace", "ArrowLeft" etc.
+        this.__enabledCharRegExp.test(event.key)
       );
     }
 
-    /**
-     * @param {unknown} newVal
-     * @param {unknown} oldVal
-     * @protected
-     */
-    _valueChanged(newVal, oldVal) {
-      // Setting initial value to empty string, skip validation
-      if (newVal === '' && oldVal === undefined) {
-        return;
-      }
-
-      if (newVal !== '' && newVal != null) {
-        this.setAttribute('has-value', '');
-      } else {
-        this.removeAttribute('has-value');
-      }
-
-      // Value is set before an element is connected to the DOM:
-      // this case is handled separately in `connectedCallback`.
-      if (!this._inputNode) {
-        return;
+    /** @private */
+    _onPaste(e) {
+      if (this._enabledCharPattern) {
+        const pastedText = (e.clipboardData || window.clipboardData).getData('text');
+        if (!this.__enabledTextRegExp.test(pastedText)) {
+          e.preventDefault();
+        }
       }
+    }
 
-      // Value is set by the user, no need to sync it back to input.
-      // Also no need to validate, as we call `validate` on blur.
-      if (this.__userInput) {
-        return;
+    /** @private */
+    _onDrop(e) {
+      if (this._enabledCharPattern) {
+        const draggedText = e.dataTransfer.getData('text');
+        if (!this.__enabledTextRegExp.test(draggedText)) {
+          e.preventDefault();
+        }
       }
+    }
 
-      // Setting a value programmatically, sync it to input element.
-      if (newVal != undefined) {
-        this._inputNode.value = newVal;
-      } else {
-        this.clear();
+    /** @private */
+    _onBeforeInput(e) {
+      // The `beforeinput` event covers all the cases for `_enabledCharPattern`: keyboard, pasting and dropping,
+      // but it is still experimental technology so we can't rely on it. It's used here just as an additional check,
+      // because it seems to be the only way to detect and prevent specific keys on mobile devices.
+      // See https://github.com/vaadin/vaadin-text-field/issues/429
+      if (this._enabledCharPattern && e.data && !this.__enabledTextRegExp.test(e.data)) {
+        e.preventDefault();
       }
+    }
 
-      // Validate the field after a new value is set programmatically.
-      if (this.invalid) {
-        this.validate();
+    /** @private */
+    _enabledCharPatternChanged(charPattern) {
+      if (charPattern) {
+        this.__enabledCharRegExp = new RegExp('^' + charPattern + '$');
+        this.__enabledTextRegExp = new RegExp('^' + charPattern + '*$');
       }
     }
   };
-
-/**
- * A mixin to provide logic for vaadin-text-field and related components.
- */
-export const InputFieldMixin = dedupingMixin(InputFieldMixinImplementation);

package/src/input-mixin.d.ts

@@ -3,10 +3,10 @@
  * Copyright (c) 2021 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { SlotMixin } from './slot-mixin.js';
 
 /**
- * A mixin to add `<input>` element to the corresponding named slot.
+ * A mixin to store the reference to an input element
+ * and add input and change event listeners to it.
  */
 declare function InputMixin<T extends new (...args: any[]) => {}>(base: T): T & InputMixinConstructor;
 
@@ -14,11 +14,27 @@ interface InputMixinConstructor {
   new (...args: any[]): InputMixin;
 }
 
-interface InputMixin extends SlotMixin {
+interface InputMixin {
   /**
-   * String used to define input type.
+   * A reference to the input element controlled by the mixin.
+   * Any component implementing this mixin is expected to provide it
+   * by using `this._setInputElement(input)` Polymer API.
+   *
+   * A typical case is using `InputController` that does this automatically.
+   * However, the input element does not have to always be native <input>:
+   * as an example, <vaadin-combo-box-light> accepts other components.
    */
-  readonly type: string;
+  readonly inputElement: HTMLInputElement;
+
+  /**
+   * The value of the field.
+   */
+  value: string;
+
+  /**
+   * Clear the value of the field.
+   */
+  clear(): void;
 }
 
-export { InputMixinConstructor, InputMixin };
+export { InputMixin, InputMixinConstructor };