@vaadin/field-base 22.0.0-alpha6 → 22.0.0-alpha7

package/src/input-mixin.js

@@ -5,165 +5,176 @@
  */
 import { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';
 
-const InputMixinImplementation = (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 `InputSlotMixin` 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'
-        },
-
-        /**
-         * The value of the field.
-         */
-        value: {
-          type: String,
-          value: '',
-          observer: '_valueChanged',
-          notify: true
-        }
-      };
-    }
+/**
+ * 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();
+      constructor() {
+        super();
 
-      this._boundOnInput = this._onInput.bind(this);
-      this._boundOnChange = this._onChange.bind(this);
-    }
+        this._boundOnInput = this._onInput.bind(this);
+        this._boundOnChange = this._onChange.bind(this);
+      }
 
-    /**
-     * Clear the value of the field.
-     */
-    clear() {
-      this.value = '';
-    }
+      /**
+       * Clear the value of the field.
+       */
+      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);
-    }
+      /**
+       * 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);
-    }
+      /**
+       * 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;
+        }
 
-    /**
-     * 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;
+        if (value != undefined) {
+          this.inputElement.value = value;
+        } else {
+          this.inputElement.value = '';
+        }
       }
 
-      if (value != undefined) {
-        this.inputElement.value = value;
-      } else {
-        this.inputElement.value = '';
+      /** @protected */
+      _inputElementChanged(input, oldInput) {
+        if (input) {
+          this._addInputListeners(input);
+        } else if (oldInput) {
+          this._removeInputListeners(oldInput);
+        }
       }
-    }
 
-    /** @protected */
-    _inputElementChanged(input, oldInput) {
-      if (input) {
-        this._addInputListeners(input);
-      } else if (oldInput) {
-        this._removeInputListeners(oldInput);
+      /**
+       * 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;
       }
-    }
 
-    /**
-     * 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;
-    }
+      /**
+       * A change event listener.
+       * Override this method with an actual implementation.
+       * @param {Event} _event
+       * @protected
+       * @override
+       */
+      _onChange(_event) {}
+
+      /**
+       * Toggle the has-value attribute based on the value property.
+       * @param {boolean} hasValue
+       * @protected
+       */
+      _toggleHasValue(hasValue) {
+        this.toggleAttribute('has-value', hasValue);
+      }
 
-    /**
-     * A change event listener.
-     * Override this method with an actual implementation.
-     * @param {Event} _event
-     * @protected
-     * @override
-     */
-    _onChange(_event) {}
-
-    /**
-     * 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;
+        }
 
-    /**
-     * 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;
+        }
 
-      // Value is set by the user, no need to sync it back to input.
-      if (this.__userInput) {
-        return;
+        // Setting a value programmatically, sync it to input element.
+        this._forwardInputValue(newVal);
       }
-
-      // Setting a value programmatically, sync it to input element.
-      this._forwardInputValue(newVal);
     }
-  };
-
-/**
- * A mixin to store the reference to an input element
- * and add input and change event listeners to it.
- */
-export const InputMixin = dedupingMixin(InputMixinImplementation);
+);

package/src/label-mixin.d.ts

@@ -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

@@ -6,75 +6,88 @@
 import { dedupingMixin } from '@polymer/polymer/lib/utils/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);
+        }
+      }
+    }
+);

package/src/pattern-mixin.js

@@ -3,12 +3,17 @@
  * 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 { timeOut } from '@polymer/polymer/lib/utils/async.js';
-import { dedupingMixin } from '@polymer/polymer/lib/utils/mixin.js';
+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';
 
-const PatternMixinImplementation = (superclass) =>
+/**
+ * A mixin to provide `pattern` and `preventInvalidInput` properties.
+ *
+ * @polymerMixin
+ * @mixes InputConstraintsMixin
+ */
+export const PatternMixin = (superclass) =>
   class PatternMixinClass extends InputConstraintsMixin(superclass) {
     static get properties() {
       return {
@@ -65,8 +70,3 @@ const PatternMixinImplementation = (superclass) =>
       super._onInput(event);
     }
   };
-
-/**
- * A mixin to provide `pattern` and `preventInvalidInput` properties.
- */
-export const PatternMixin = dedupingMixin(PatternMixinImplementation);

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;
+    }
+  }
+}