@vaadin/field-base 23.1.1 → 23.2.0-alpha1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/field-base",
-  "version": "23.1.1",
+  "version": "23.2.0-alpha1",
   "publishConfig": {
     "access": "public"
   },
@@ -32,7 +32,7 @@
   "dependencies": {
     "@open-wc/dedupe-mixin": "^1.3.0",
     "@polymer/polymer": "^3.0.0",
-    "@vaadin/component-base": "^23.1.1",
+    "@vaadin/component-base": "23.2.0-alpha1",
     "lit": "^2.0.0"
   },
   "devDependencies": {
@@ -40,5 +40,5 @@
     "@vaadin/testing-helpers": "^0.3.2",
     "sinon": "^13.0.2"
   },
-  "gitHead": "390458d6519433a2dd502cef90da48e84573a275"
+  "gitHead": "f226a2976c270d3d53c824f6e0a740a5d3382d91"
 }

package/src/field-mixin.js

@@ -89,10 +89,6 @@ export const FieldMixin = (superclass) =>
       this._helperController = new HelperController(this);
       this._errorController = new ErrorController(this);
 
-      this.addController(this._fieldAriaController);
-      this.addController(this._helperController);
-      this.addController(this._errorController);
-
       this._labelController.addEventListener('label-changed', (event) => {
         const { hasLabel, node } = event.detail;
         this.__labelChanged(hasLabel, node);
@@ -104,6 +100,15 @@ export const FieldMixin = (superclass) =>
       });
     }
 
+    /** @protected */
+    ready() {
+      super.ready();
+
+      this.addController(this._fieldAriaController);
+      this.addController(this._helperController);
+      this.addController(this._errorController);
+    }
+
     /** @private */
     __helperChanged(hasHelper, helperNode) {
       if (hasHelper) {

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

@@ -36,6 +36,19 @@ export declare function InputControlMixin<T extends Constructor<HTMLElement>>(
   Constructor<ValidateMixinClass>;
 
 export declare class InputControlMixinClass {
+  /**
+   * A pattern matched against individual characters the user inputs.
+   *
+   * When set, the field will prevent:
+   * - `keydown` events if the entered key doesn't match `/^allowedCharPattern$/`
+   * - `paste` events if the pasted text doesn't match `/^allowedCharPattern*$/`
+   * - `drop` events if the dropped text doesn't match `/^allowedCharPattern*$/`
+   *
+   * For example, to allow entering only numbers and minus signs, use:
+   * `allowedCharPattern = "[\\d-]"`
+   */
+  allowedCharPattern: string;
+
   /**
    * If true, the input text gets fully selected when the field is focused using click or touch / tap.
    */

package/src/input-control-mixin.js

@@ -3,6 +3,8 @@
  * Copyright (c) 2021 - 2022 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
+import { timeOut } from '@vaadin/component-base/src/async.js';
+import { Debouncer } from '@vaadin/component-base/src/debounce.js';
 import { KeyboardMixin } from '@vaadin/component-base/src/keyboard-mixin.js';
 import { DelegateFocusMixin } from './delegate-focus-mixin.js';
 import { FieldMixin } from './field-mixin.js';
@@ -23,6 +25,22 @@ export const InputControlMixin = (superclass) =>
   ) {
     static get properties() {
       return {
+        /**
+         * A pattern matched against individual characters the user inputs.
+         *
+         * When set, the field will prevent:
+         * - `keydown` events if the entered key doesn't match `/^allowedCharPattern$/`
+         * - `paste` events if the pasted text doesn't match `/^allowedCharPattern*$/`
+         * - `drop` events if the dropped text doesn't match `/^allowedCharPattern*$/`
+         *
+         * For example, to allow entering only numbers and minus signs, use:
+         * `allowedCharPattern = "[\\d-]"`
+         */
+        allowedCharPattern: {
+          type: String,
+          observer: '_allowedCharPatternChanged',
+        },
+
         /**
          * If true, the input text gets fully selected when the field is focused using click or touch / tap.
          */
@@ -80,6 +98,14 @@ export const InputControlMixin = (superclass) =>
       return [...super.delegateAttrs, 'name', 'type', 'placeholder', 'readonly', 'invalid', 'title'];
     }
 
+    constructor() {
+      super();
+
+      this._boundOnPaste = this._onPaste.bind(this);
+      this._boundOnDrop = this._onDrop.bind(this);
+      this._boundOnBeforeInput = this._onBeforeInput.bind(this);
+    }
+
     /**
      * Any element extending this mixin is required to implement this getter.
      * It returns the reference to the clear button element.
@@ -172,6 +198,115 @@ export const InputControlMixin = (superclass) =>
       this.inputElement.dispatchEvent(new Event('change', { bubbles: true }));
     }
 
+    /**
+     * 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);
+    }
+
+    /**
+     * Override a method from `InputMixin`.
+     * @param {!HTMLElement} input
+     * @protected
+     * @override
+     */
+    _removeInputListeners(input) {
+      super._removeInputListeners(input);
+
+      input.removeEventListener('paste', this._boundOnPaste);
+      input.removeEventListener('drop', this._boundOnDrop);
+      input.removeEventListener('beforeinput', this._boundOnBeforeInput);
+    }
+
+    /**
+     * Override an event listener from `KeyboardMixin`.
+     * @param {!KeyboardEvent} event
+     * @protected
+     * @override
+     */
+    _onKeyDown(event) {
+      super._onKeyDown(event);
+
+      if (this.allowedCharPattern && !this.__shouldAcceptKey(event)) {
+        event.preventDefault();
+        this._markInputPrevented();
+      }
+    }
+
+    /** @protected */
+    _markInputPrevented() {
+      // Add input-prevented attribute for 200ms
+      this.setAttribute('input-prevented', '');
+      this._preventInputDebouncer = Debouncer.debounce(this._preventInputDebouncer, timeOut.after(200), () => {
+        this.removeAttribute('input-prevented');
+      });
+    }
+
+    /** @private */
+    __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.__allowedCharRegExp.test(event.key)
+      );
+    }
+
+    /** @private */
+    _onPaste(e) {
+      if (this.allowedCharPattern) {
+        const pastedText = e.clipboardData.getData('text');
+        if (!this.__allowedTextRegExp.test(pastedText)) {
+          e.preventDefault();
+          this._markInputPrevented();
+        }
+      }
+    }
+
+    /** @private */
+    _onDrop(e) {
+      if (this.allowedCharPattern) {
+        const draggedText = e.dataTransfer.getData('text');
+        if (!this.__allowedTextRegExp.test(draggedText)) {
+          e.preventDefault();
+          this._markInputPrevented();
+        }
+      }
+    }
+
+    /** @private */
+    _onBeforeInput(e) {
+      // The `beforeinput` event covers all the cases for `allowedCharPattern`: 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.allowedCharPattern && e.data && !this.__allowedTextRegExp.test(e.data)) {
+        e.preventDefault();
+        this._markInputPrevented();
+      }
+    }
+
+    /** @private */
+    _allowedCharPatternChanged(charPattern) {
+      if (charPattern) {
+        try {
+          this.__allowedCharRegExp = new RegExp(`^${charPattern}$`);
+          this.__allowedTextRegExp = new RegExp(`^${charPattern}*$`);
+        } catch (e) {
+          console.error(e);
+        }
+      }
+    }
+
     /**
      * Fired when the user commits a value change.
      *

package/src/input-controller.js

@@ -23,9 +23,7 @@ export class InputController extends SlotController {
         }
 
         // Ensure every instance has unique ID
-        const uniqueId = (InputController._uniqueInputId = 1 + InputController._uniqueInputId || 0);
-        host._inputId = `${host.localName}-${uniqueId}`;
-        node.id = host._inputId;
+        node.id = this.defaultId;
 
         if (typeof callback === 'function') {
           callback(node);

package/src/input-field-mixin.js

@@ -47,22 +47,6 @@ export const InputFieldMixin = (superclass) =>
         autocapitalize: {
           type: String,
         },
-
-        /**
-         * 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
-         */
-        _enabledCharPattern: {
-          type: String,
-          observer: '_enabledCharPatternChanged',
-        },
       };
     }
 
@@ -70,14 +54,6 @@ export const InputFieldMixin = (superclass) =>
       return [...super.delegateAttrs, 'autocapitalize', 'autocomplete', 'autocorrect'];
     }
 
-    constructor() {
-      super();
-
-      this._boundOnPaste = this._onPaste.bind(this);
-      this._boundOnDrop = this._onDrop.bind(this);
-      this._boundOnBeforeInput = this._onBeforeInput.bind(this);
-    }
-
     /**
      * @param {HTMLElement} input
      * @protected
@@ -149,97 +125,4 @@ export const InputFieldMixin = (superclass) =>
         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);
-    }
-
-    /**
-     * Override a method from `InputMixin`.
-     * @param {!HTMLElement} input
-     * @protected
-     * @override
-     */
-    _removeInputListeners(input) {
-      super._removeInputListeners(input);
-
-      input.removeEventListener('paste', this._boundOnPaste);
-      input.removeEventListener('drop', this._boundOnDrop);
-      input.removeEventListener('beforeinput', this._boundOnBeforeInput);
-    }
-
-    /**
-     * Override an event listener from `InputControlMixin`
-     * to avoid adding a separate listener.
-     * @param {!KeyboardEvent} event
-     * @protected
-     * @override
-     */
-    _onKeyDown(event) {
-      if (this._enabledCharPattern && !this.__shouldAcceptKey(event)) {
-        event.preventDefault();
-      }
-
-      super._onKeyDown(event);
-    }
-
-    /** @private */
-    __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)
-      );
-    }
-
-    /** @private */
-    _onPaste(e) {
-      if (this._enabledCharPattern) {
-        const pastedText = (e.clipboardData || window.clipboardData).getData('text');
-        if (!this.__enabledTextRegExp.test(pastedText)) {
-          e.preventDefault();
-        }
-      }
-    }
-
-    /** @private */
-    _onDrop(e) {
-      if (this._enabledCharPattern) {
-        const draggedText = e.dataTransfer.getData('text');
-        if (!this.__enabledTextRegExp.test(draggedText)) {
-          e.preventDefault();
-        }
-      }
-    }
-
-    /** @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();
-      }
-    }
-
-    /** @private */
-    _enabledCharPatternChanged(charPattern) {
-      if (charPattern) {
-        this.__enabledCharRegExp = new RegExp(`^${charPattern}$`);
-        this.__enabledTextRegExp = new RegExp(`^${charPattern}*$`);
-      }
-    }
   };

package/src/label-mixin.js

@@ -43,6 +43,12 @@ export const LabelMixin = dedupingMixin(
         super();
 
         this._labelController = new LabelController(this);
+      }
+
+      /** @protected */
+      ready() {
+        super.ready();
+
         this.addController(this._labelController);
       }
 

package/src/pattern-mixin.d.ts

@@ -34,6 +34,7 @@ export declare class PatternMixinClass {
    * When set to true, user is prevented from typing a value that
    * conflicts with the given `pattern`.
    * @attr {boolean} prevent-invalid-input
+   * @deprecated Please use `allowedCharPattern` instead.
    */
   preventInvalidInput: boolean | null | undefined;
 }

package/src/pattern-mixin.js

@@ -29,9 +29,11 @@ export const PatternMixin = (superclass) =>
          * When set to true, user is prevented from typing a value that
          * conflicts with the given `pattern`.
          * @attr {boolean} prevent-invalid-input
+         * @deprecated Please use `allowedCharPattern` instead.
          */
         preventInvalidInput: {
           type: Boolean,
+          observer: '_preventInvalidInputChanged',
         },
       };
     }
@@ -68,4 +70,13 @@ export const PatternMixin = (superclass) =>
 
       super._onInput(event);
     }
+
+    /** @private */
+    _preventInvalidInputChanged(preventInvalidInput) {
+      if (preventInvalidInput) {
+        console.warn(
+          `WARNING: Since Vaadin 23.2, "preventInvalidInput" is deprecated. Please use "allowedCharPattern" instead.`,
+        );
+      }
+    }
   };

package/src/slot-target-controller.js

@@ -41,7 +41,11 @@ export class SlotTargetController {
 
     // Ensure the content is up to date when host is connected
     // to handle e.g. mutating text content while disconnected.
-    this.__checkAndCopyNodesToSlotTarget();
+    // Note, `hostConnected()` is called twice if the controller
+    // is initialized in `ready()` when using `ControllerMixin`.
+    if (!this.__copying) {
+      this.__checkAndCopyNodesToSlotTarget();
+    }
   }
 
   /**

package/src/text-area-controller.js

@@ -25,10 +25,7 @@ export class TextAreaController extends SlotController {
           node.setAttribute('name', name);
         }
 
-        // Ensure every instance has unique ID
-        const uniqueId = (TextAreaController._uniqueTextAreaId = 1 + TextAreaController._uniqueTextAreaId || 0);
-        host._textareaId = `${host.localName}-${uniqueId}`;
-        node.id = host._textareaId;
+        node.id = this.defaultId;
 
         if (typeof callback === 'function') {
           callback(node);