@vaadin/field-base 25.2.0-alpha9 → 25.2.0-beta1

package/src/validate-mixin.js

@@ -7,110 +7,100 @@ import { dedupeMixin } from '@open-wc/dedupe-mixin';
 
 /**
  * A mixin to provide required state and validation logic.
- *
- * @polymerMixin
  */
-export const ValidateMixin = dedupeMixin(
-  (superclass) =>
-    class ValidateMixinClass extends superclass {
-      static get properties() {
-        return {
-          /**
-           * Set to true when the field is invalid.
-           */
-          invalid: {
-            type: Boolean,
-            reflectToAttribute: true,
-            notify: true,
-            value: false,
-            sync: true,
-          },
+const ValidateMixinImplementation = (superclass) =>
+  class extends superclass {
+    static get properties() {
+      return {
+        /**
+         * Set to true when the field is invalid.
+         */
+        invalid: {
+          type: Boolean,
+          reflectToAttribute: true,
+          notify: true,
+          value: false,
+          sync: true,
+        },
 
-          /**
-           * Set to true to enable manual validation mode. This mode disables automatic
-           * constraint validation, allowing you to control the validation process yourself.
-           * You can still trigger constraint validation manually with the `validate()` method
-           * or use `checkValidity()` to assess the component's validity without affecting
-           * the invalid state. In manual validation mode, you can also manipulate
-           * the `invalid` property directly through your application logic without conflicts
-           * with the component's internal validation.
-           *
-           * @attr {boolean} manual-validation
-           */
-          manualValidation: {
-            type: Boolean,
-            value: false,
-          },
+        /**
+         * Set to true to enable manual validation mode. This mode disables automatic
+         * constraint validation, allowing you to control the validation process yourself.
+         * You can still trigger constraint validation manually with the `validate()` method
+         * or use `checkValidity()` to assess the component's validity without affecting
+         * the invalid state. In manual validation mode, you can also manipulate
+         * the `invalid` property directly through your application logic without conflicts
+         * with the component's internal validation.
+         *
+         * @attr {boolean} manual-validation
+         */
+        manualValidation: {
+          type: Boolean,
+          value: false,
+        },
 
-          /**
-           * Specifies that the user must fill in a value.
-           */
-          required: {
-            type: Boolean,
-            reflectToAttribute: true,
-            sync: true,
-          },
-        };
-      }
+        /**
+         * Specifies that the user must fill in a value.
+         */
+        required: {
+          type: Boolean,
+          reflectToAttribute: true,
+          sync: true,
+        },
+      };
+    }
 
-      /**
-       * Validates the field and sets the `invalid` property based on the result.
-       *
-       * The method fires a `validated` event with the result of the validation.
-       *
-       * @return {boolean} True if the value is valid.
-       */
-      validate() {
-        const isValid = this.checkValidity();
-        this._setInvalid(!isValid);
-        this.dispatchEvent(new CustomEvent('validated', { detail: { valid: isValid } }));
-        return isValid;
-      }
+    /**
+     * Validates the field and sets the `invalid` property based on the result.
+     *
+     * The method fires a `validated` event with the result of the validation.
+     *
+     * @return {boolean} True if the value is valid.
+     */
+    validate() {
+      const isValid = this.checkValidity();
+      this._setInvalid(!isValid);
+      this.dispatchEvent(new CustomEvent('validated', { detail: { valid: isValid } }));
+      return isValid;
+    }
 
-      /**
-       * Returns true if the field value satisfies all constraints (if any).
-       *
-       * @return {boolean}
-       */
-      checkValidity() {
-        return !this.required || !!this.value;
-      }
+    /**
+     * Returns true if the field value satisfies all constraints (if any).
+     *
+     * @return {boolean}
+     */
+    checkValidity() {
+      return !this.required || !!this.value;
+    }
 
-      /**
-       * @param {boolean} invalid
-       * @protected
-       */
-      _setInvalid(invalid) {
-        if (this._shouldSetInvalid(invalid)) {
-          this.invalid = invalid;
-        }
+    /**
+     * @param {boolean} invalid
+     * @protected
+     */
+    _setInvalid(invalid) {
+      if (this._shouldSetInvalid(invalid)) {
+        this.invalid = invalid;
       }
+    }
 
-      /**
-       * Override this method to define whether the given `invalid` state should be set.
-       *
-       * @param {boolean} _invalid
-       * @return {boolean}
-       * @protected
-       */
-      _shouldSetInvalid(_invalid) {
-        return true;
-      }
+    /**
+     * Override this method to define whether the given `invalid` state should be set.
+     *
+     * @param {boolean} _invalid
+     * @return {boolean}
+     * @protected
+     */
+    _shouldSetInvalid(_invalid) {
+      return true;
+    }
 
-      /** @protected */
-      _requestValidation() {
-        if (!this.manualValidation) {
-          // eslint-disable-next-line no-restricted-syntax
-          this.validate();
-        }
+    /** @protected */
+    _requestValidation() {
+      if (!this.manualValidation) {
+        // eslint-disable-next-line no-restricted-syntax
+        this.validate();
       }
+    }
+  };
 
-      /**
-       * Fired whenever the field is validated.
-       *
-       * @event validated
-       * @param {Object} detail
-       * @param {boolean} detail.valid the result of the validation.
-       */
-    },
-);
+export const ValidateMixin = dedupeMixin(ValidateMixinImplementation);

package/src/virtual-keyboard-controller.d.ts

@@ -11,4 +11,12 @@ import type { ReactiveController } from 'lit';
  */
 export class VirtualKeyboardController implements ReactiveController {
   constructor(host: HTMLElement & { inputElement?: HTMLElement; opened: boolean });
+
+  /**
+   * Phantom optional method to satisfy the `ReactiveController` interface
+   * (TS2559: an interface with all-optional members needs at least one
+   * declared property in common). Not implemented at runtime; Lit's
+   * `addController` invokes it via optional chaining.
+   */
+  hostConnected?(): void;
 }