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

package/src/input-mixin.js

@@ -4,67 +4,177 @@
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
 import { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';
-import { SlotMixin } from './slot-mixin.js';
 
-const InputMixinImplementation = (superclass) =>
-  class InputMixinClass extends SlotMixin(superclass) {
-    static get properties() {
+/**
+ * A mixin to store the reference to an input element
+ * and add input and change event listeners to it.
+ *
+ * @polymerMixin
+ */
+export const InputMixin = dedupingMixin(
+  (superclass) =>
+    class InputMixinClass extends superclass {
+      static get properties() {
+        return {
+          /**
+           * 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.
+           *
+           * @protected
+           * @type {!HTMLElement}
+           */
+          inputElement: {
+            type: Object,
+            readOnly: true,
+            observer: '_inputElementChanged'
+          },
+
+          /**
+           * String used to define input type.
+           * @protected
+           */
+          type: {
+            type: String,
+            readOnly: true
+          },
+
+          /**
+           * The value of the field.
+           */
+          value: {
+            type: String,
+            value: '',
+            observer: '_valueChanged',
+            notify: true
+          }
+        };
+      }
+
+      constructor() {
+        super();
+
+        this._boundOnInput = this._onInput.bind(this);
+        this._boundOnChange = this._onChange.bind(this);
+      }
+
       /**
-       * String used to define input type.
+       * Clear the value of the field.
        */
-      return {
-        type: {
-          type: String,
-          readOnly: true
+      clear() {
+        this.value = '';
+      }
+
+      /**
+       * Add event listeners to the input element instance.
+       * Override this method to add custom listeners.
+       * @param {!HTMLElement} input
+       */
+      _addInputListeners(input) {
+        input.addEventListener('input', this._boundOnInput);
+        input.addEventListener('change', this._boundOnChange);
+      }
+
+      /**
+       * Remove event listeners from the input element instance.
+       * @param {!HTMLElement} input
+       */
+      _removeInputListeners(input) {
+        input.removeEventListener('input', this._boundOnInput);
+        input.removeEventListener('change', this._boundOnChange);
+      }
+
+      /**
+       * A method to forward the value property set on the field
+       * programmatically back to the input element value.
+       * Override this method to perform additional checks,
+       * for example to skip this in certain conditions.
+       * @param {string} value
+       * @protected
+       * @override
+       */
+      _forwardInputValue(value) {
+        // Value might be set before an input element is initialized.
+        // This case should be handled separately by a component that
+        // implements this mixin, for example in `connectedCallback`.
+        if (!this.inputElement) {
+          return;
         }
-      };
-    }
 
-    get slots() {
-      return {
-        ...super.slots,
-        input: () => {
-          const native = document.createElement('input');
-          const value = this.getAttribute('value');
-          if (value) {
-            native.setAttribute('value', value);
-          }
-          const name = this.getAttribute('name');
-          if (name) {
-            native.setAttribute('name', name);
-          }
-          if (this.type) {
-            native.setAttribute('type', this.type);
-          }
-          return native;
+        if (value != undefined) {
+          this.inputElement.value = value;
+        } else {
+          this.inputElement.value = '';
         }
-      };
-    }
+      }
 
-    /** @protected */
-    get _inputNode() {
-      return this._getDirectSlotChild('input');
-    }
+      /** @protected */
+      _inputElementChanged(input, oldInput) {
+        if (input) {
+          this._addInputListeners(input);
+        } else if (oldInput) {
+          this._removeInputListeners(oldInput);
+        }
+      }
 
-    constructor() {
-      super();
+      /**
+       * An input event listener used to update the field value.
+       * Override this method with an actual implementation.
+       * @param {Event} _event
+       * @protected
+       * @override
+       */
+      _onInput(event) {
+        // Ignore fake input events e.g. used by clear button.
+        this.__userInput = event.isTrusted;
+        this.value = event.target.value;
+        this.__userInput = false;
+      }
 
-      // Ensure every instance has unique ID
-      const uniqueId = (InputMixinClass._uniqueId = 1 + InputMixinClass._uniqueId || 0);
-      this._inputId = `${this.localName}-${uniqueId}`;
-    }
+      /**
+       * A change event listener.
+       * Override this method with an actual implementation.
+       * @param {Event} _event
+       * @protected
+       * @override
+       */
+      _onChange(_event) {}
 
-    /** @protected */
-    connectedCallback() {
-      super.connectedCallback();
+      /**
+       * Toggle the has-value attribute based on the value property.
+       * @param {boolean} hasValue
+       * @protected
+       */
+      _toggleHasValue(hasValue) {
+        this.toggleAttribute('has-value', hasValue);
+      }
+
+      /**
+       * Observer called when a value property changes.
+       * @param {string | undefined} newVal
+       * @param {string | undefined} oldVal
+       * @protected
+       * @override
+       */
+      _valueChanged(newVal, oldVal) {
+        this._toggleHasValue(newVal !== '' && newVal != null);
+
+        // Setting initial value to empty string, do nothing.
+        if (newVal === '' && oldVal === undefined) {
+          return;
+        }
+
+        // Value is set by the user, no need to sync it back to input.
+        if (this.__userInput) {
+          return;
+        }
 
-      if (this._inputNode) {
-        this._inputNode.id = this._inputId;
+        // Setting a value programmatically, sync it to input element.
+        this._forwardInputValue(newVal);
       }
     }
-  };
-
-/**
- * A mixin to add `<input>` element to the corresponding named slot.
- */
-export const InputMixin = dedupingMixin(InputMixinImplementation);
+);

package/src/label-mixin.d.ts

@@ -3,7 +3,7 @@
  * 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';
+import { SlotMixin } from '@vaadin/component-base/src/slot-mixin.js';
 
 /**
  * A mixin to provide label via corresponding property or named slot.
@@ -18,7 +18,7 @@ interface LabelMixin extends SlotMixin {
   /**
    * String used for a label element.
    */
-  label: string;
+  label: string | null | undefined;
 }
 
 export { LabelMixinConstructor, LabelMixin };

package/src/label-mixin.js

@@ -4,77 +4,91 @@
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
 import { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';
-import { SlotMixin } from './slot-mixin.js';
+import { SlotMixin } from '@vaadin/component-base/src/slot-mixin.js';
 
-const LabelMixinImplementation = (superclass) =>
-  class LabelMixinClass extends SlotMixin(superclass) {
-    static get properties() {
-      return {
-        /**
-         * The label text for the input node.
-         * When no light dom defined via [slot=label], this value will be used.
-         */
-        label: {
-          type: String,
-          observer: '_labelChanged'
-        }
-      };
-    }
+/**
+ * A mixin to provide label via corresponding property or named slot.
+ *
+ * @polymerMixin
+ * @mixes SlotMixin
+ */
+export const LabelMixin = dedupingMixin(
+  (superclass) =>
+    class LabelMixinClass extends SlotMixin(superclass) {
+      static get properties() {
+        return {
+          /**
+           * The label text for the input node.
+           * When no light dom defined via [slot=label], this value will be used.
+           */
+          label: {
+            type: String,
+            observer: '_labelChanged'
+          }
+        };
+      }
 
-    get slots() {
-      return {
-        ...super.slots,
-        label: () => {
-          const label = document.createElement('label');
-          label.textContent = this.label;
-          return label;
-        }
-      };
-    }
+      /** @protected */
+      get slots() {
+        return {
+          ...super.slots,
+          label: () => {
+            const label = document.createElement('label');
+            label.textContent = this.label;
+            return label;
+          }
+        };
+      }
 
-    /** @protected */
-    get _labelNode() {
-      return this._getDirectSlotChild('label');
-    }
+      /** @protected */
+      get _labelNode() {
+        return this._getDirectSlotChild('label');
+      }
 
-    constructor() {
-      super();
+      constructor() {
+        super();
 
-      // Ensure every instance has unique ID
-      const uniqueId = (LabelMixinClass._uniqueId = 1 + LabelMixinClass._uniqueId || 0);
-      this._labelId = `label-${this.localName}-${uniqueId}`;
-    }
+        // Ensure every instance has unique ID
+        const uniqueId = (LabelMixinClass._uniqueLabelId = 1 + LabelMixinClass._uniqueLabelId || 0);
+        this._labelId = `label-${this.localName}-${uniqueId}`;
 
-    /** @protected */
-    connectedCallback() {
-      super.connectedCallback();
+        /**
+         * @type {MutationObserver}
+         * @private
+         */
+        this.__labelNodeObserver = new MutationObserver(() => {
+          this._toggleHasLabelAttribute();
+        });
+      }
 
-      if (this._labelNode) {
-        this._labelNode.id = this._labelId;
+      /** @protected */
+      ready() {
+        super.ready();
 
-        this._applyCustomLabel();
-      }
-    }
+        if (this._labelNode) {
+          this._labelNode.id = this._labelId;
+          this._toggleHasLabelAttribute();
 
-    /** @protected */
-    _applyCustomLabel() {
-      const label = this._labelNode.textContent;
-      if (label !== this.label) {
-        this.label = label;
+          this.__labelNodeObserver.observe(this._labelNode, { childList: true });
+        }
       }
-    }
 
-    /** @protected */
-    _labelChanged(label) {
-      if (this._labelNode) {
-        this._labelNode.textContent = label;
+      /** @protected */
+      _labelChanged(label) {
+        if (this._labelNode) {
+          this._labelNode.textContent = label;
+          this._toggleHasLabelAttribute();
+        }
       }
 
-      this.toggleAttribute('has-label', Boolean(label));
-    }
-  };
+      /** @protected */
+      _toggleHasLabelAttribute() {
+        if (this._labelNode) {
+          const hasLabel = this._labelNode.children.length > 0 || this._labelNode.textContent.trim() !== '';
 
-/**
- * A mixin to provide label via corresponding property or named slot.
- */
-export const LabelMixin = dedupingMixin(LabelMixinImplementation);
+          this.toggleAttribute('has-label', hasLabel);
+          this.dispatchEvent(new CustomEvent('has-label-changed', { detail: { value: hasLabel } }));
+        }
+      }
+    }
+);

package/src/pattern-mixin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { InputConstraintsMixin } from './input-constraints-mixin.js';
+
+/**
+ * A mixin to provide `pattern` and `preventInvalidInput` properties.
+ */
+declare function PatternMixin<T extends new (...args: any[]) => {}>(base: T): T & PatternMixinConstructor;
+
+interface PatternMixinConstructor {
+  new (...args: any[]): PatternMixin;
+}
+
+interface PatternMixin extends InputConstraintsMixin {
+  /**
+   * A regular expression that the value is checked against.
+   * The pattern must match the entire value, not just some subset.
+   */
+  pattern: string;
+
+  /**
+   * When set to true, user is prevented from typing a value that
+   * conflicts with the given `pattern`.
+   * @attr {boolean} prevent-invalid-input
+   */
+  preventInvalidInput: boolean | null | undefined;
+}
+
+export { PatternMixin, PatternMixinConstructor };

package/src/pattern-mixin.js

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { Debouncer } from '@vaadin/component-base/src/debounce.js';
+import { timeOut } from '@vaadin/component-base/src/async.js';
+import { InputConstraintsMixin } from './input-constraints-mixin.js';
+
+/**
+ * A mixin to provide `pattern` and `preventInvalidInput` properties.
+ *
+ * @polymerMixin
+ * @mixes InputConstraintsMixin
+ */
+export const PatternMixin = (superclass) =>
+  class PatternMixinClass extends InputConstraintsMixin(superclass) {
+    static get properties() {
+      return {
+        /**
+         * A regular expression that the value is checked against.
+         * The pattern must match the entire value, not just some subset.
+         */
+        pattern: {
+          type: String
+        },
+
+        /**
+         * When set to true, user is prevented from typing a value that
+         * conflicts with the given `pattern`.
+         * @attr {boolean} prevent-invalid-input
+         */
+        preventInvalidInput: {
+          type: Boolean
+        }
+      };
+    }
+
+    static get delegateAttrs() {
+      return [...super.delegateAttrs, 'pattern'];
+    }
+
+    static get constraints() {
+      return [...super.constraints, 'pattern'];
+    }
+
+    /** @private */
+    _checkInputValue() {
+      if (this.preventInvalidInput) {
+        const input = this.inputElement;
+        if (input && input.value.length > 0 && !this.checkValidity()) {
+          input.value = this.value || '';
+          // add input-prevented attribute for 200ms
+          this.setAttribute('input-prevented', '');
+          this._inputDebouncer = Debouncer.debounce(this._inputDebouncer, timeOut.after(200), () => {
+            this.removeAttribute('input-prevented');
+          });
+          return;
+        }
+      }
+    }
+
+    /**
+     * @param {Event} event
+     * @protected
+     */
+    _onInput(event) {
+      this._checkInputValue();
+
+      super._onInput(event);
+    }
+  };

package/src/shadow-focus-mixin.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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 { TabindexMixin } from '@vaadin/component-base/src/tabindex-mixin.js';
+import { DelegateFocusMixin } from './delegate-focus-mixin.js';
+
+/**
+ * A mixin to forward focus to an element in the shadow DOM.
+ */
+declare function ShadowFocusMixin<T extends new (...args: any[]) => {}>(base: T): T & ShadowFocusMixinConstructor;
+
+interface ShadowFocusMixinConstructor {
+  new (...args: any[]): ShadowFocusMixin;
+}
+
+interface ShadowFocusMixin extends KeyboardMixin, TabindexMixin, DelegateFocusMixin {}
+
+export { ShadowFocusMixinConstructor, ShadowFocusMixin };

package/src/shadow-focus-mixin.js

@@ -0,0 +1,87 @@
+/**
+ * @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 { TabindexMixin } from '@vaadin/component-base/src/tabindex-mixin.js';
+import { DelegateFocusMixin } from './delegate-focus-mixin.js';
+
+/**
+ * A mixin to forward focus to an element in the shadow DOM.
+ *
+ * @polymerMixin
+ * @mixes DelegateFocusMixin
+ * @mixes KeyboardMixin
+ * @mixes TabindexMixin
+ */
+export const ShadowFocusMixin = (superClass) =>
+  class ShadowFocusMixinClass extends TabindexMixin(DelegateFocusMixin(KeyboardMixin(superClass))) {
+    /**
+     * Override an event listener from `KeyboardMixin`
+     * to prevent setting `focused` on Shift Tab.
+     * @param {KeyboardEvent} event
+     * @protected
+     * @override
+     */
+    _onKeyDown(event) {
+      super._onKeyDown(event);
+
+      // When focus moves with Shift + Tab, do not mark host as focused.
+      // The flag set here will be later used in focusin event listener.
+      if (!event.defaultPrevented && event.keyCode === 9 && event.shiftKey) {
+        this._isShiftTabbing = true;
+        HTMLElement.prototype.focus.apply(this);
+        this._setFocused(false);
+        setTimeout(() => (this._isShiftTabbing = false), 0);
+      }
+    }
+
+    /**
+     * Override method inherited from `FocusMixin`
+     * to support focusElement in Shadow DOM.
+     * @param {Event} event
+     * @return {boolean}
+     * @protected
+     * @override
+     */
+    _shouldSetFocus(event) {
+      if (!this.disabled && this.focusElement) {
+        const path = event.composedPath();
+
+        // When focus moves from outside and not with Shift + Tab, delegate it to focusElement.
+        if (path[0] === this && !this.contains(event.relatedTarget) && !this._isShiftTabbing) {
+          this.focusElement.focus();
+          return true;
+        }
+
+        if (path.includes(this.focusElement)) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    /**
+     * Override an observer from `TabindexMixin`.
+     * Do not call super to remove tabindex attribute
+     * from host when disabled by setting undefined.
+     * @param {string} tabindex
+     * @protected
+     * @override
+     */
+    _tabindexChanged(tabindex) {
+      if (tabindex !== undefined) {
+        this.focusElement.tabIndex = tabindex;
+      }
+
+      if (this.disabled && tabindex) {
+        // If tabindex attribute was changed while component was disabled
+        if (tabindex !== -1) {
+          this.__lastTabIndex = tabindex;
+        }
+        this.tabindex = undefined;
+      }
+    }
+  };

package/src/slot-controller.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { ReactiveController } from 'lit';
+
+export class SlotController implements ReactiveController {}

package/src/slot-controller.js

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+export class SlotController {
+  constructor(host, [slotName, slotFactory, slotInitializer]) {
+    this.host = host;
+    this.slotName = slotName;
+    this.slotFactory = slotFactory;
+    this.slotInitializer = slotInitializer;
+  }
+
+  hostConnected() {
+    if (!this.__initialized) {
+      const { host, slotName, slotFactory } = this;
+
+      const slotted = host.querySelector(`[slot=${slotName}]`);
+
+      if (!slotted) {
+        const slotContent = slotFactory(host);
+        if (slotContent instanceof Element) {
+          slotContent.setAttribute('slot', slotName);
+          host.appendChild(slotContent);
+          this.__slotContent = slotContent;
+        }
+      } else {
+        this.__slotContent = slotted;
+      }
+
+      this.slotInitializer(host, this.__slotContent);
+
+      this.__initialized = true;
+    }
+  }
+}

package/src/slot-label-mixin.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { LabelMixin } from './label-mixin.js';
+import { SlotTargetMixin } from './slot-target-mixin.js';
+
+/**
+ * A mixin to forward any content from the default slot to the label node.
+ */
+declare function SlotLabelMixin<T extends new (...args: any[]) => {}>(base: T): T & SlotLabelMixinConstructor;
+
+interface SlotLabelMixinConstructor {
+  new (...args: any[]): SlotLabelMixin;
+}
+
+interface SlotLabelMixin extends SlotTargetMixin, LabelMixin {}
+
+export { SlotLabelMixinConstructor, SlotLabelMixin };