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

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

package/src/slot-label-mixin.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * 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 { 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.
+ *
+ * @polymerMixin
+ * @mixes LabelMixin
+ * @mixes SlotTargetMixin
+ */
+export const SlotLabelMixin = dedupingMixin(
+  (superclass) =>
+    class SlotLabelMixinClass extends SlotTargetMixin(LabelMixin(superclass)) {
+      /** @protected */
+      get _slotTarget() {
+        return this._labelNode;
+      }
+
+      /** @protected */
+      ready() {
+        super.ready();
+
+        if (this._labelNode) {
+          // The default slot's content is moved to the label node
+          // only after `LabelMixin` is initialized which means
+          // we should manually toggle the `has-label` attribute
+          // respecting the new label content.
+          this._toggleHasLabelAttribute();
+        }
+      }
+    }
+);

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

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+
+/**
+ * Mixin to insert styles into the outer scope to handle slotted components.
+ * This is useful e.g. to hide native `<input type="number">` controls.
+ */
+declare function SlotStylesMixin<T extends new (...args: any[]) => {}>(base: T): T & SlotStylesMixinConstructor;
+
+interface SlotStylesMixinConstructor {
+  new (...args: any[]): SlotStylesMixin;
+}
+
+interface SlotStylesMixin {
+  /**
+   * List of styles to insert into root.
+   */
+  readonly slotStyles: string[];
+}
+
+export { SlotStylesMixinConstructor, SlotStylesMixin };

package/src/slot-styles-mixin.js

@@ -0,0 +1,76 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * 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';
+
+const stylesMap = new WeakMap();
+
+/**
+ * Get all the styles inserted into root.
+ * @param {DocumentOrShadowRoot} root
+ * @return {Set<string>}
+ */
+function getRootStyles(root) {
+  if (!stylesMap.has(root)) {
+    stylesMap.set(root, new Set());
+  }
+
+  return stylesMap.get(root);
+}
+
+/**
+ * Insert styles into the root.
+ * @param {string} styles
+ * @param {DocumentOrShadowRoot} root
+ */
+function insertStyles(styles, root) {
+  const style = document.createElement('style');
+  style.textContent = styles;
+
+  if (root === document) {
+    document.head.appendChild(style);
+  } else {
+    root.insertBefore(style, root.firstChild);
+  }
+}
+
+/**
+ * Mixin to insert styles into the outer scope to handle slotted components.
+ * This is useful e.g. to hide native `<input type="number">` controls.
+ *
+ * @polymerMixin
+ */
+export const SlotStylesMixin = dedupingMixin(
+  (superclass) =>
+    class SlotStylesMixinClass extends superclass {
+      /**
+       * List of styles to insert into root.
+       * @protected
+       */
+      get slotStyles() {
+        return {};
+      }
+
+      /** @protected */
+      connectedCallback() {
+        super.connectedCallback();
+
+        this.__applySlotStyles();
+      }
+
+      /** @private */
+      __applySlotStyles() {
+        const root = this.getRootNode();
+        const rootStyles = getRootStyles(root);
+
+        this.slotStyles.forEach((styles) => {
+          if (!rootStyles.has(styles)) {
+            insertStyles(styles, root);
+            rootStyles.add(styles);
+          }
+        });
+      }
+    }
+);

package/src/slot-target-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/
+ */
+
+/**
+ * A mixin to copy the content from a source slot to a target element.
+ */
+declare function SlotTargetMixin<T extends new (...args: any[]) => {}>(base: T): T & SlotTargetMixinConstructor;
+
+interface SlotTargetMixinConstructor {
+  new (...args: any[]): SlotTargetMixin;
+}
+
+interface SlotTargetMixin {
+  /**
+   * A reference to the source slot from which the content is copied to the target element.
+   *
+   * @protected
+   */
+  _sourceSlot: HTMLSlotElement;
+
+  /**
+   * A reference to the target element to which the content is copied from the source slot.
+   *
+   * @protected
+   */
+  _slotTarget: HTMLElement;
+}
+
+export { SlotTargetMixinConstructor, SlotTargetMixin };

package/src/slot-target-mixin.js

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * 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';
+
+/**
+ * A mixin to copy the content from a source slot to a target element.
+ *
+ * @polymerMixin
+ */
+export const SlotTargetMixin = dedupingMixin(
+  (superclass) =>
+    class SlotTargetMixinClass extends superclass {
+      /** @protected */
+      ready() {
+        super.ready();
+
+        if (this._sourceSlot) {
+          this.__sourceSlotObserver = new MutationObserver(() => this.__checkAndCopyNodesToSlotTarget());
+
+          this.__checkAndCopyNodesToSlotTarget();
+
+          this._sourceSlot.addEventListener('slotchange', () => {
+            this.__checkAndCopyNodesToSlotTarget();
+          });
+        }
+      }
+
+      /**
+       * A reference to the source slot from which the nodes are copied to the target element.
+       *
+       * @type {HTMLSlotElement | null}
+       * @protected
+       */
+      get _sourceSlot() {
+        console.warn(`Please implement the '_sourceSlot' property in <${this.localName}>`);
+        return null;
+      }
+
+      /**
+       * A reference to the target element to which the nodes are copied from the source slot.
+       *
+       * @type {HTMLElement | null}
+       * @protected
+       */
+      get _slotTarget() {
+        console.warn(`Please implement the '_slotTarget' property in <${this.localName}>`);
+        return null;
+      }
+
+      /**
+       * Copies every node from the source slot to the target element
+       * once the source slot' content is changed.
+       *
+       * @private
+       */
+      __checkAndCopyNodesToSlotTarget() {
+        this.__sourceSlotObserver.disconnect();
+
+        if (!this._slotTarget) {
+          return;
+        }
+
+        // Remove any existing clones from the slot target
+        if (this.__slotTargetClones) {
+          this.__slotTargetClones.forEach((node) => {
+            if (node.parentElement === this._slotTarget) {
+              this._slotTarget.removeChild(node);
+            }
+          });
+          delete this.__slotTargetClones;
+        }
+
+        // Exclude whitespace text nodes
+        const nodes = this._sourceSlot
+          .assignedNodes({ flatten: true })
+          .filter((node) => !(node.nodeType == Node.TEXT_NODE && node.textContent.trim() === ''));
+
+        if (nodes.length > 0) {
+          this._slotTarget.innerHTML = '';
+          this.__copyNodesToSlotTarget(nodes);
+        }
+      }
+
+      /**
+       * Copies the nodes to the target element.
+       *
+       * @protected
+       * @param {!Array<!Node>} nodes
+       */
+      __copyNodesToSlotTarget(nodes) {
+        this.__slotTargetClones = this.__slotTargetClones || [];
+        nodes.forEach((node) => {
+          // Clone the nodes and append the clones to the target slot
+          const clone = node.cloneNode(true);
+          this.__slotTargetClones.push(clone);
+          this._slotTarget.appendChild(clone);
+          // Observe all changes to the source node to have the clones updated
+          this.__sourceSlotObserver.observe(node, {
+            attributes: true,
+            childList: true,
+            subtree: true,
+            characterData: true
+          });
+        });
+      }
+    }
+);

package/src/styles/clear-button-styles.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 { CSSResult } from 'lit';
+
+export const clearButton: CSSResult;

package/src/styles/clear-button-styles.js

@@ -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 { css } from 'lit';
+
+export const clearButton = css`
+  [part='clear-button'] {
+    display: none;
+    cursor: default;
+  }
+
+  [part='clear-button']::before {
+    content: '✕';
+  }
+
+  :host([clear-button-visible][has-value]:not([disabled]):not([readonly])) [part='clear-button'] {
+    display: block;
+  }
+`;

package/src/styles/field-shared-styles.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 { CSSResult } from 'lit';
+
+export const fieldShared: CSSResult;

package/src/styles/field-shared-styles.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { css } from 'lit';
+
+export const fieldShared = css`
+  :host {
+    display: inline-flex;
+    outline: none;
+  }
+
+  :host::before {
+    content: '\\2003';
+    width: 0;
+    display: inline-block;
+    /* Size and position this element on the same vertical position as the input-field element
+          to make vertical align for the host element work as expected */
+  }
+
+  :host([hidden]) {
+    display: none !important;
+  }
+
+  :host(:not([has-label])) [part='label'] {
+    display: none;
+  }
+`;

package/src/styles/input-field-container-styles.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 { CSSResult } from 'lit';
+
+export const inputFieldContainer: CSSResult;

package/src/styles/input-field-container-styles.js

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { css } from 'lit';
+
+export const inputFieldContainer = css`
+  [class$='container'] {
+    display: flex;
+    flex-direction: column;
+    min-width: 100%;
+    max-width: 100%;
+    width: var(--vaadin-field-default-width, 12em);
+  }
+`;

package/src/styles/input-field-shared-styles.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 { CSSResult } from 'lit';
+
+export const inputFieldShared: CSSResult;

package/src/styles/input-field-shared-styles.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright (c) 2021 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { clearButton } from './clear-button-styles.js';
+import { fieldShared } from './field-shared-styles.js';
+import { inputFieldContainer } from './input-field-container-styles.js';
+
+export const inputFieldShared = [fieldShared, inputFieldContainer, clearButton];

package/src/text-area-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 `<textarea>` element.
+ */
+export class TextAreaController implements SlotController {}

package/src/text-area-controller.js

@@ -0,0 +1,38 @@
+/**
+ * @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 `<textarea>` element.
+ */
+export class TextAreaController extends SlotController {
+  constructor(host, callback) {
+    super(host, [
+      'textarea',
+      () => document.createElement('textarea'),
+      (host, node) => {
+        const value = host.getAttribute('value');
+        if (value) {
+          node.value = value;
+        }
+
+        const name = host.getAttribute('name');
+        if (name) {
+          node.setAttribute('name', name);
+        }
+
+        // Ensure every instance has unique ID
+        const uniqueId = (TextAreaController._uniqueTextAreaId = 1 + TextAreaController._uniqueInputId || 0);
+        host._textareaId = `${host.localName}-${uniqueId}`;
+        node.id = host._textareaId;
+
+        if (typeof callback == 'function') {
+          callback(node);
+        }
+      }
+    ]);
+  }
+}

package/src/validate-mixin.d.ts

@@ -3,7 +3,6 @@
  * 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 provide required state and validation logic.
@@ -14,7 +13,7 @@ interface ValidateMixinConstructor {
   new (...args: any[]): ValidateMixin;
 }
 
-interface ValidateMixin extends SlotMixin {
+interface ValidateMixin {
   /**
    * Set to true when the field is invalid.
    */
@@ -25,13 +24,6 @@ interface ValidateMixin extends SlotMixin {
    */
   required: boolean;
 
-  /**
-   * Error to show when the field is invalid.
-   *
-   * @attr {string} error-message
-   */
-  errorMessage: string;
-
   /**
    * Returns true if field is valid, and sets `invalid` based on the field validity.
    */