@vaadin/checkbox-group 24.4.0-dev.b3e1d14600 → 24.5.0-alpha1

package/README.md

@@ -5,7 +5,6 @@ A web component that allows the user to choose several items from a group of bin
 [Documentation + Live Demo ↗](https://vaadin.com/docs/latest/components/checkbox)
 
 [![npm version](https://badgen.net/npm/v/@vaadin/checkbox-group)](https://www.npmjs.com/package/@vaadin/checkbox-group)
-[![Discord](https://img.shields.io/discord/732335336448852018?label=discord)](https://discord.gg/PHmkCKC)
 
 ```html
 <vaadin-checkbox-group label="Export data">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vaadin/checkbox-group",
-  "version": "24.4.0-dev.b3e1d14600",
+  "version": "24.5.0-alpha1",
   "publishConfig": {
     "access": "public"
   },
@@ -25,7 +25,9 @@
     "vaadin-*.d.ts",
     "vaadin-*.js",
     "web-types.json",
-    "web-types.lit.json"
+    "web-types.lit.json",
+    "!vaadin-lit-*.d.ts",
+    "!vaadin-lit-*.js"
   ],
   "keywords": [
     "Vaadin",
@@ -35,14 +37,15 @@
     "polymer"
   ],
   "dependencies": {
+    "@open-wc/dedupe-mixin": "^1.3.0",
     "@polymer/polymer": "^3.0.0",
-    "@vaadin/a11y-base": "24.4.0-dev.b3e1d14600",
-    "@vaadin/checkbox": "24.4.0-dev.b3e1d14600",
-    "@vaadin/component-base": "24.4.0-dev.b3e1d14600",
-    "@vaadin/field-base": "24.4.0-dev.b3e1d14600",
-    "@vaadin/vaadin-lumo-styles": "24.4.0-dev.b3e1d14600",
-    "@vaadin/vaadin-material-styles": "24.4.0-dev.b3e1d14600",
-    "@vaadin/vaadin-themable-mixin": "24.4.0-dev.b3e1d14600"
+    "@vaadin/a11y-base": "24.5.0-alpha1",
+    "@vaadin/checkbox": "24.5.0-alpha1",
+    "@vaadin/component-base": "24.5.0-alpha1",
+    "@vaadin/field-base": "24.5.0-alpha1",
+    "@vaadin/vaadin-lumo-styles": "24.5.0-alpha1",
+    "@vaadin/vaadin-material-styles": "24.5.0-alpha1",
+    "@vaadin/vaadin-themable-mixin": "24.5.0-alpha1"
   },
   "devDependencies": {
     "@esm-bundle/chai": "^4.3.4",
@@ -53,5 +56,5 @@
     "web-types.json",
     "web-types.lit.json"
   ],
-  "gitHead": "502d4f5b03f770a83d270d98078cde230254dd0e"
+  "gitHead": "57806caac5468532a3b4e3dbdda730cd0fca193a"
 }

package/src/vaadin-checkbox-group-mixin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import type { Constructor } from '@open-wc/dedupe-mixin';
+import type { DisabledMixinClass } from '@vaadin/a11y-base/src/disabled-mixin.js';
+import type { FocusMixinClass } from '@vaadin/a11y-base/src/focus-mixin.js';
+import type { ControllerMixinClass } from '@vaadin/component-base/src/controller-mixin.js';
+import type { FieldMixinClass } from '@vaadin/field-base/src/field-mixin.js';
+import type { LabelMixinClass } from '@vaadin/field-base/src/label-mixin.js';
+import type { ValidateMixinClass } from '@vaadin/field-base/src/validate-mixin.js';
+
+/**
+ * A mixin providing common checkbox-group functionality.
+ */
+export declare function CheckboxGroupMixin<T extends Constructor<HTMLElement>>(
+  base: T,
+): Constructor<CheckboxGroupMixinClass> &
+  Constructor<ControllerMixinClass> &
+  Constructor<DisabledMixinClass> &
+  Constructor<FieldMixinClass> &
+  Constructor<FocusMixinClass> &
+  Constructor<LabelMixinClass> &
+  Constructor<ValidateMixinClass> &
+  T;
+
+export declare class CheckboxGroupMixinClass {
+  /**
+   * An array containing values of the currently checked checkboxes.
+   *
+   * The array is immutable so toggling checkboxes always results in
+   * creating a new array.
+   */
+  value: string[];
+
+  /**
+   * When true, the user cannot modify the value of the checkbox group.
+   * The difference between `disabled` and `readonly` is that in the
+   * read-only checkbox group, all the checkboxes are also read-only,
+   * and therefore remain focusable and announced by screen readers.
+   */
+  readonly: boolean;
+}

package/src/vaadin-checkbox-group-mixin.js

@@ -0,0 +1,308 @@
+/**
+ * @license
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { DisabledMixin } from '@vaadin/a11y-base/src/disabled-mixin.js';
+import { FocusMixin } from '@vaadin/a11y-base/src/focus-mixin.js';
+import { SlotObserver } from '@vaadin/component-base/src/slot-observer.js';
+import { TooltipController } from '@vaadin/component-base/src/tooltip-controller.js';
+import { FieldMixin } from '@vaadin/field-base/src/field-mixin.js';
+
+/**
+ * A mixin providing common checkbox-group functionality.
+ *
+ * @polymerMixin
+ * @mixes DisabledMixin
+ * @mixes FieldMixin
+ * @mixes FocusMixin
+ * @mixes KeyboardMixin
+ */
+export const CheckboxGroupMixin = (superclass) =>
+  class CheckboxGroupMixinClass extends FieldMixin(FocusMixin(DisabledMixin(superclass))) {
+    static get properties() {
+      return {
+        /**
+         * An array containing values of the currently checked checkboxes.
+         *
+         * The array is immutable so toggling checkboxes always results in
+         * creating a new array.
+         *
+         * @type {!Array<!string>}
+         */
+        value: {
+          type: Array,
+          value: () => [],
+          notify: true,
+          sync: true,
+          observer: '__valueChanged',
+        },
+
+        /**
+         * When true, the user cannot modify the value of the checkbox group.
+         * The difference between `disabled` and `readonly` is that in the
+         * read-only checkbox group, all the checkboxes are also read-only,
+         * and therefore remain focusable and announced by screen readers.
+         */
+        readonly: {
+          type: Boolean,
+          value: false,
+          reflectToAttribute: true,
+          observer: '__readonlyChanged',
+        },
+      };
+    }
+
+    constructor() {
+      super();
+
+      this.__registerCheckbox = this.__registerCheckbox.bind(this);
+      this.__unregisterCheckbox = this.__unregisterCheckbox.bind(this);
+      this.__onCheckboxCheckedChanged = this.__onCheckboxCheckedChanged.bind(this);
+
+      this._tooltipController = new TooltipController(this);
+      this._tooltipController.addEventListener('tooltip-changed', (event) => {
+        const tooltip = event.detail.node;
+        if (tooltip && tooltip.isConnected) {
+          // Tooltip element has been added to the DOM
+          const inputs = this.__checkboxes.map((checkbox) => checkbox.inputElement);
+          this._tooltipController.setAriaTarget(inputs);
+        } else {
+          // Tooltip element is no longer connected
+          this._tooltipController.setAriaTarget([]);
+        }
+      });
+    }
+
+    /**
+     * A collection of the checkboxes.
+     *
+     * @return {!Array<!Checkbox>}
+     * @private
+     */
+    get __checkboxes() {
+      return this.__filterCheckboxes([...this.children]);
+    }
+
+    /** @protected */
+    ready() {
+      super.ready();
+
+      this.ariaTarget = this;
+
+      // See https://github.com/vaadin/vaadin-web-components/issues/94
+      this.setAttribute('role', 'group');
+
+      const slot = this.shadowRoot.querySelector('slot:not([name])');
+      this._observer = new SlotObserver(slot, ({ addedNodes, removedNodes }) => {
+        const addedCheckboxes = this.__filterCheckboxes(addedNodes);
+        const removedCheckboxes = this.__filterCheckboxes(removedNodes);
+
+        addedCheckboxes.forEach(this.__registerCheckbox);
+        removedCheckboxes.forEach(this.__unregisterCheckbox);
+
+        const inputs = this.__checkboxes.map((checkbox) => checkbox.inputElement);
+        this._tooltipController.setAriaTarget(inputs);
+
+        this.__warnOfCheckboxesWithoutValue(addedCheckboxes);
+      });
+
+      this.addController(this._tooltipController);
+    }
+
+    /**
+     * Override method inherited from `ValidateMixin`
+     * to validate the value array.
+     *
+     * @override
+     * @return {boolean}
+     */
+    checkValidity() {
+      return !this.required || this.value.length > 0;
+    }
+
+    /**
+     * @param {!Array<!Node>} nodes
+     * @return {!Array<!Checkbox>}
+     * @private
+     */
+    __filterCheckboxes(nodes) {
+      return nodes.filter((node) => node.nodeType === Node.ELEMENT_NODE && node.localName === 'vaadin-checkbox');
+    }
+
+    /**
+     * @param {!Array<!Checkbox>} checkboxes
+     * @private
+     */
+    __warnOfCheckboxesWithoutValue(checkboxes) {
+      const hasCheckboxesWithoutValue = checkboxes.some((checkbox) => {
+        const { value } = checkbox;
+
+        return !checkbox.hasAttribute('value') && (!value || value === 'on');
+      });
+
+      if (hasCheckboxesWithoutValue) {
+        console.warn('Please provide the value attribute to all the checkboxes inside the checkbox group.');
+      }
+    }
+
+    /**
+     * Registers the checkbox after adding it to the group.
+     *
+     * @param {!Checkbox} checkbox
+     * @private
+     */
+    __registerCheckbox(checkbox) {
+      checkbox.addEventListener('checked-changed', this.__onCheckboxCheckedChanged);
+
+      if (this.disabled) {
+        checkbox.disabled = true;
+      }
+
+      if (this.readonly) {
+        checkbox.readonly = true;
+      }
+
+      if (checkbox.checked) {
+        this.__addCheckboxToValue(checkbox.value);
+      } else if (this.value.includes(checkbox.value)) {
+        checkbox.checked = true;
+      }
+    }
+
+    /**
+     * Unregisters the checkbox before removing it from the group.
+     *
+     * @param {!Checkbox} checkbox
+     * @private
+     */
+    __unregisterCheckbox(checkbox) {
+      checkbox.removeEventListener('checked-changed', this.__onCheckboxCheckedChanged);
+
+      if (checkbox.checked) {
+        this.__removeCheckboxFromValue(checkbox.value);
+      }
+    }
+
+    /**
+     * Override method inherited from `DisabledMixin`
+     * to propagate the `disabled` property to the checkboxes.
+     *
+     * @param {boolean} newValue
+     * @param {boolean} oldValue
+     * @override
+     * @protected
+     */
+    _disabledChanged(newValue, oldValue) {
+      super._disabledChanged(newValue, oldValue);
+
+      // Prevent updating the `disabled` property for the checkboxes at initialization.
+      // Otherwise, the checkboxes may end up enabled regardless the `disabled` attribute
+      // intentionally added by the user on some of them.
+      if (!newValue && oldValue === undefined) {
+        return;
+      }
+
+      if (oldValue !== newValue) {
+        this.__checkboxes.forEach((checkbox) => {
+          checkbox.disabled = newValue;
+        });
+      }
+    }
+
+    /**
+     * @param {string} value
+     * @private
+     */
+    __addCheckboxToValue(value) {
+      if (!this.value.includes(value)) {
+        this.value = [...this.value, value];
+      }
+    }
+
+    /**
+     * @param {string} value
+     * @private
+     */
+    __removeCheckboxFromValue(value) {
+      if (this.value.includes(value)) {
+        this.value = this.value.filter((v) => v !== value);
+      }
+    }
+
+    /**
+     * @param {!CustomEvent} event
+     * @private
+     */
+    __onCheckboxCheckedChanged(event) {
+      const checkbox = event.target;
+
+      if (checkbox.checked) {
+        this.__addCheckboxToValue(checkbox.value);
+      } else {
+        this.__removeCheckboxFromValue(checkbox.value);
+      }
+    }
+
+    /**
+     * @param {string | null | undefined} value
+     * @param {string | null | undefined} oldValue
+     * @private
+     */
+    __valueChanged(value, oldValue) {
+      // Setting initial value to empty array, skip validation
+      if (value.length === 0 && oldValue === undefined) {
+        return;
+      }
+
+      this.toggleAttribute('has-value', value.length > 0);
+
+      this.__checkboxes.forEach((checkbox) => {
+        checkbox.checked = value.includes(checkbox.value);
+      });
+
+      if (oldValue !== undefined) {
+        this.validate();
+      }
+    }
+
+    /** @private */
+    __readonlyChanged(readonly, oldReadonly) {
+      if (readonly || oldReadonly) {
+        this.__checkboxes.forEach((checkbox) => {
+          checkbox.readonly = readonly;
+        });
+      }
+    }
+
+    /**
+     * Override method inherited from `FocusMixin`
+     * to prevent removing the `focused` attribute
+     * when focus moves between checkboxes inside the group.
+     *
+     * @param {!FocusEvent} event
+     * @return {boolean}
+     * @protected
+     */
+    _shouldRemoveFocus(event) {
+      return !this.contains(event.relatedTarget);
+    }
+
+    /**
+     * Override method inherited from `FocusMixin`
+     * to run validation when the group loses focus.
+     *
+     * @param {boolean} focused
+     * @override
+     * @protected
+     */
+    _setFocused(focused) {
+      super._setFocused(focused);
+
+      // Do not validate when focusout is caused by document
+      // losing focus, which happens on browser tab switch.
+      if (!focused && document.hasFocus()) {
+        this.validate();
+      }
+    }
+  };

package/src/vaadin-checkbox-group-styles.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import type { CSSResult } from 'lit';
+
+export const checkboxGroupStyles: CSSResult;

package/src/vaadin-checkbox-group-styles.js

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { css } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+
+export const checkboxGroupStyles = css`
+  :host {
+    display: inline-flex;
+  }
+
+  :host::before {
+    content: '\\2003';
+    width: 0;
+    display: inline-block;
+  }
+
+  :host([hidden]) {
+    display: none !important;
+  }
+
+  .vaadin-group-field-container {
+    display: flex;
+    flex-direction: column;
+    width: 100%;
+  }
+
+  [part='group-field'] {
+    display: flex;
+    flex-wrap: wrap;
+  }
+
+  :host(:not([has-label])) [part='label'] {
+    display: none;
+  }
+`;

package/src/vaadin-checkbox-group.d.ts

@@ -1,13 +1,11 @@
 /**
  * @license
- * Copyright (c) 2018 - 2023 Vaadin Ltd.
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
-import { DisabledMixin } from '@vaadin/a11y-base/src/disabled-mixin.js';
-import { FocusMixin } from '@vaadin/a11y-base/src/focus-mixin.js';
 import { ElementMixin } from '@vaadin/component-base/src/element-mixin.js';
-import { FieldMixin } from '@vaadin/field-base/src/field-mixin.js';
 import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+import { CheckboxGroupMixin } from './vaadin-checkbox-group-mixin.js';
 
 /**
  * Fired when the `invalid` property changes.
@@ -63,6 +61,7 @@ export interface CheckboxGroupEventMap extends HTMLElementEventMap, CheckboxGrou
  * Attribute           | Description                               | Part name
  * --------------------|-------------------------------------------|------------
  * `disabled`          | Set when the element is disabled          | :host
+ * `readonly`          | Set when the element is readonly          | :host
  * `invalid`           | Set when the element is invalid           | :host
  * `focused`           | Set when the element is focused           | :host
  * `has-label`         | Set when the element has a label          | :host
@@ -76,15 +75,7 @@ export interface CheckboxGroupEventMap extends HTMLElementEventMap, CheckboxGrou
  * @fires {CustomEvent} value-changed - Fired when the `value` property changes.
  * @fires {CustomEvent} validated - Fired whenever the field is validated.
  */
-declare class CheckboxGroup extends FieldMixin(FocusMixin(DisabledMixin(ElementMixin(ThemableMixin(HTMLElement))))) {
-  /**
-   * An array containing values of the currently checked checkboxes.
-   *
-   * The array is immutable so toggling checkboxes always results in
-   * creating a new array.
-   */
-  value: string[];
-
+declare class CheckboxGroup extends CheckboxGroupMixin(ElementMixin(ThemableMixin(HTMLElement))) {
   addEventListener<K extends keyof CheckboxGroupEventMap>(
     type: K,
     listener: (this: CheckboxGroup, ev: CheckboxGroupEventMap[K]) => void,

package/src/vaadin-checkbox-group.js

@@ -1,18 +1,17 @@
 /**
  * @license
- * Copyright (c) 2018 - 2023 Vaadin Ltd.
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
+import '@vaadin/checkbox/src/vaadin-checkbox.js';
 import { html, PolymerElement } from '@polymer/polymer/polymer-element.js';
-import { DisabledMixin } from '@vaadin/a11y-base/src/disabled-mixin.js';
-import { FocusMixin } from '@vaadin/a11y-base/src/focus-mixin.js';
-import { Checkbox } from '@vaadin/checkbox/src/vaadin-checkbox.js';
 import { defineCustomElement } from '@vaadin/component-base/src/define.js';
 import { ElementMixin } from '@vaadin/component-base/src/element-mixin.js';
-import { SlotObserver } from '@vaadin/component-base/src/slot-observer.js';
-import { TooltipController } from '@vaadin/component-base/src/tooltip-controller.js';
-import { FieldMixin } from '@vaadin/field-base/src/field-mixin.js';
-import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+import { registerStyles, ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+import { CheckboxGroupMixin } from './vaadin-checkbox-group-mixin.js';
+import { checkboxGroupStyles } from './vaadin-checkbox-group-styles.js';
+
+registerStyles('vaadin-checkbox-group', checkboxGroupStyles, { moduleId: 'vaadin-checkbox-group-styles' });
 
 /**
  * `<vaadin-checkbox-group>` is a web component that allows the user to choose several items from a group of binary choices.
@@ -43,6 +42,7 @@ import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mix
  * Attribute           | Description                               | Part name
  * --------------------|-------------------------------------------|------------
  * `disabled`          | Set when the element is disabled          | :host
+ * `readonly`          | Set when the element is readonly          | :host
  * `invalid`           | Set when the element is invalid           | :host
  * `focused`           | Set when the element is focused           | :host
  * `has-label`         | Set when the element has a label          | :host
@@ -59,49 +59,16 @@ import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mix
  * @customElement
  * @extends HTMLElement
  * @mixes ThemableMixin
- * @mixes DisabledMixin
  * @mixes ElementMixin
- * @mixes FocusMixin
- * @mixes FieldMixin
+ * @mixes CheckboxGroupMixin
  */
-class CheckboxGroup extends FieldMixin(FocusMixin(DisabledMixin(ElementMixin(ThemableMixin(PolymerElement))))) {
+class CheckboxGroup extends CheckboxGroupMixin(ElementMixin(ThemableMixin(PolymerElement))) {
   static get is() {
     return 'vaadin-checkbox-group';
   }
 
   static get template() {
     return html`
-      <style>
-        :host {
-          display: inline-flex;
-        }
-
-        :host::before {
-          content: '\\2003';
-          width: 0;
-          display: inline-block;
-        }
-
-        :host([hidden]) {
-          display: none !important;
-        }
-
-        .vaadin-group-field-container {
-          display: flex;
-          flex-direction: column;
-          width: 100%;
-        }
-
-        [part='group-field'] {
-          display: flex;
-          flex-wrap: wrap;
-        }
-
-        :host(:not([has-label])) [part='label'] {
-          display: none;
-        }
-      </style>
-
       <div class="vaadin-group-field-container">
         <div part="label">
           <slot name="label"></slot>
@@ -124,265 +91,6 @@ class CheckboxGroup extends FieldMixin(FocusMixin(DisabledMixin(ElementMixin(The
       <slot name="tooltip"></slot>
     `;
   }
-
-  static get properties() {
-    return {
-      /**
-       * An array containing values of the currently checked checkboxes.
-       *
-       * The array is immutable so toggling checkboxes always results in
-       * creating a new array.
-       *
-       * @type {!Array<!string>}
-       */
-      value: {
-        type: Array,
-        value: () => [],
-        notify: true,
-        observer: '__valueChanged',
-      },
-    };
-  }
-
-  constructor() {
-    super();
-
-    this.__registerCheckbox = this.__registerCheckbox.bind(this);
-    this.__unregisterCheckbox = this.__unregisterCheckbox.bind(this);
-    this.__onCheckboxCheckedChanged = this.__onCheckboxCheckedChanged.bind(this);
-
-    this._tooltipController = new TooltipController(this);
-    this._tooltipController.addEventListener('tooltip-changed', (event) => {
-      const tooltip = event.detail.node;
-      if (tooltip && tooltip.isConnected) {
-        // Tooltip element has been added to the DOM
-        const inputs = this.__checkboxes.map((checkbox) => checkbox.inputElement);
-        this._tooltipController.setAriaTarget(inputs);
-      } else {
-        // Tooltip element is no longer connected
-        this._tooltipController.setAriaTarget([]);
-      }
-    });
-  }
-
-  /**
-   * A collection of the checkboxes.
-   *
-   * @return {!Array<!Checkbox>}
-   * @private
-   */
-  get __checkboxes() {
-    return this.__filterCheckboxes([...this.children]);
-  }
-
-  /** @protected */
-  ready() {
-    super.ready();
-
-    this.ariaTarget = this;
-
-    // See https://github.com/vaadin/vaadin-web-components/issues/94
-    this.setAttribute('role', 'group');
-
-    const slot = this.shadowRoot.querySelector('slot:not([name])');
-    this._observer = new SlotObserver(slot, ({ addedNodes, removedNodes }) => {
-      const addedCheckboxes = this.__filterCheckboxes(addedNodes);
-      const removedCheckboxes = this.__filterCheckboxes(removedNodes);
-
-      addedCheckboxes.forEach(this.__registerCheckbox);
-      removedCheckboxes.forEach(this.__unregisterCheckbox);
-
-      const inputs = this.__checkboxes.map((checkbox) => checkbox.inputElement);
-      this._tooltipController.setAriaTarget(inputs);
-
-      this.__warnOfCheckboxesWithoutValue(addedCheckboxes);
-    });
-
-    this.addController(this._tooltipController);
-  }
-
-  /**
-   * Override method inherited from `ValidateMixin`
-   * to validate the value array.
-   *
-   * @override
-   * @return {boolean}
-   */
-  checkValidity() {
-    return !this.required || this.value.length > 0;
-  }
-
-  /**
-   * @param {!Array<!Node>} nodes
-   * @return {!Array<!Checkbox>}
-   * @private
-   */
-  __filterCheckboxes(nodes) {
-    return nodes.filter((child) => child instanceof Checkbox);
-  }
-
-  /**
-   * @param {!Array<!Checkbox>} checkboxes
-   * @private
-   */
-  __warnOfCheckboxesWithoutValue(checkboxes) {
-    const hasCheckboxesWithoutValue = checkboxes.some((checkbox) => {
-      const { value } = checkbox;
-
-      return !checkbox.hasAttribute('value') && (!value || value === 'on');
-    });
-
-    if (hasCheckboxesWithoutValue) {
-      console.warn('Please provide the value attribute to all the checkboxes inside the checkbox group.');
-    }
-  }
-
-  /**
-   * Registers the checkbox after adding it to the group.
-   *
-   * @param {!Checkbox} checkbox
-   * @private
-   */
-  __registerCheckbox(checkbox) {
-    checkbox.addEventListener('checked-changed', this.__onCheckboxCheckedChanged);
-
-    if (this.disabled) {
-      checkbox.disabled = true;
-    }
-
-    if (checkbox.checked) {
-      this.__addCheckboxToValue(checkbox.value);
-    } else if (this.value.includes(checkbox.value)) {
-      checkbox.checked = true;
-    }
-  }
-
-  /**
-   * Unregisters the checkbox before removing it from the group.
-   *
-   * @param {!Checkbox} checkbox
-   * @private
-   */
-  __unregisterCheckbox(checkbox) {
-    checkbox.removeEventListener('checked-changed', this.__onCheckboxCheckedChanged);
-
-    if (checkbox.checked) {
-      this.__removeCheckboxFromValue(checkbox.value);
-    }
-  }
-
-  /**
-   * Override method inherited from `DisabledMixin`
-   * to propagate the `disabled` property to the checkboxes.
-   *
-   * @param {boolean} newValue
-   * @param {boolean} oldValue
-   * @override
-   * @protected
-   */
-  _disabledChanged(newValue, oldValue) {
-    super._disabledChanged(newValue, oldValue);
-
-    // Prevent updating the `disabled` property for the checkboxes at initialization.
-    // Otherwise, the checkboxes may end up enabled regardless the `disabled` attribute
-    // intentionally added by the user on some of them.
-    if (!newValue && oldValue === undefined) {
-      return;
-    }
-
-    if (oldValue !== newValue) {
-      this.__checkboxes.forEach((checkbox) => {
-        checkbox.disabled = newValue;
-      });
-    }
-  }
-
-  /**
-   * @param {string} value
-   * @private
-   */
-  __addCheckboxToValue(value) {
-    if (!this.value.includes(value)) {
-      this.value = [...this.value, value];
-    }
-  }
-
-  /**
-   * @param {string} value
-   * @private
-   */
-  __removeCheckboxFromValue(value) {
-    if (this.value.includes(value)) {
-      this.value = this.value.filter((v) => v !== value);
-    }
-  }
-
-  /**
-   * @param {!CustomEvent} event
-   * @private
-   */
-  __onCheckboxCheckedChanged(event) {
-    const checkbox = event.target;
-
-    if (checkbox.checked) {
-      this.__addCheckboxToValue(checkbox.value);
-    } else {
-      this.__removeCheckboxFromValue(checkbox.value);
-    }
-  }
-
-  /**
-   * @param {string | null | undefined} value
-   * @param {string | null | undefined} oldValue
-   * @private
-   */
-  __valueChanged(value, oldValue) {
-    // Setting initial value to empty array, skip validation
-    if (value.length === 0 && oldValue === undefined) {
-      return;
-    }
-
-    this.toggleAttribute('has-value', value.length > 0);
-
-    this.__checkboxes.forEach((checkbox) => {
-      checkbox.checked = value.includes(checkbox.value);
-    });
-
-    if (oldValue !== undefined) {
-      this.validate();
-    }
-  }
-
-  /**
-   * Override method inherited from `FocusMixin`
-   * to prevent removing the `focused` attribute
-   * when focus moves between checkboxes inside the group.
-   *
-   * @param {!FocusEvent} event
-   * @return {boolean}
-   * @protected
-   */
-  _shouldRemoveFocus(event) {
-    return !this.contains(event.relatedTarget);
-  }
-
-  /**
-   * Override method inherited from `FocusMixin`
-   * to run validation when the group loses focus.
-   *
-   * @param {boolean} focused
-   * @override
-   * @protected
-   */
-  _setFocused(focused) {
-    super._setFocused(focused);
-
-    // Do not validate when focusout is caused by document
-    // losing focus, which happens on browser tab switch.
-    if (!focused && document.hasFocus()) {
-      this.validate();
-    }
-  }
 }
 
 defineCustomElement(CheckboxGroup);

package/src/vaadin-lit-checkbox-group.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright (c) 2017 - 2024 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+export * from './vaadin-checkbox-group.js';

package/src/vaadin-lit-checkbox-group.js

@@ -0,0 +1,62 @@
+/**
+ * @license
+ * Copyright (c) 2018 - 2024 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import '@vaadin/checkbox/src/vaadin-lit-checkbox.js';
+import { html, LitElement } from 'lit';
+import { defineCustomElement } from '@vaadin/component-base/src/define.js';
+import { ElementMixin } from '@vaadin/component-base/src/element-mixin.js';
+import { PolylitMixin } from '@vaadin/component-base/src/polylit-mixin.js';
+import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+import { CheckboxGroupMixin } from './vaadin-checkbox-group-mixin.js';
+import { checkboxGroupStyles } from './vaadin-checkbox-group-styles.js';
+
+/**
+ * LitElement based version of `<vaadin-checkbox-group>` web component.
+ *
+ * ## Disclaimer
+ *
+ * This component is an experiment and not yet a part of Vaadin platform.
+ * There is no ETA regarding specific Vaadin version where it'll land.
+ * Feel free to try this code in your apps as per Apache 2.0 license.
+ */
+class CheckboxGroup extends CheckboxGroupMixin(ElementMixin(ThemableMixin(PolylitMixin(LitElement)))) {
+  static get is() {
+    return 'vaadin-checkbox-group';
+  }
+
+  static get styles() {
+    return checkboxGroupStyles;
+  }
+
+  /** @protected */
+  render() {
+    return html`
+      <div class="vaadin-group-field-container">
+        <div part="label">
+          <slot name="label"></slot>
+          <span part="required-indicator" aria-hidden="true"></span>
+        </div>
+
+        <div part="group-field">
+          <slot></slot>
+        </div>
+
+        <div part="helper-text">
+          <slot name="helper"></slot>
+        </div>
+
+        <div part="error-message">
+          <slot name="error-message"></slot>
+        </div>
+      </div>
+
+      <slot name="tooltip"></slot>
+    `;
+  }
+}
+
+defineCustomElement(CheckboxGroup);
+
+export { CheckboxGroup };

package/theme/lumo/vaadin-checkbox-group-styles.d.ts

@@ -0,0 +1,5 @@
+import '@vaadin/vaadin-lumo-styles/color.js';
+import '@vaadin/vaadin-lumo-styles/sizing.js';
+import '@vaadin/vaadin-lumo-styles/spacing.js';
+import '@vaadin/vaadin-lumo-styles/style.js';
+import '@vaadin/vaadin-lumo-styles/typography.js';

package/theme/lumo/vaadin-checkbox-group-styles.js

@@ -39,14 +39,14 @@ const checkboxGroup = css`
     color: var(--lumo-primary-text-color);
   }
 
-  :host(:hover:not([disabled]):not([focused])) [part='label'],
-  :host(:hover:not([disabled]):not([focused])) [part='helper-text'] {
+  :host(:hover:not([readonly]):not([disabled]):not([focused])) [part='label'],
+  :host(:hover:not([readonly]):not([disabled]):not([focused])) [part='helper-text'] {
     color: var(--lumo-body-text-color);
   }
 
   /* Touch device adjustment */
   @media (pointer: coarse) {
-    :host(:hover:not([disabled]):not([focused])) [part='label'] {
+    :host(:hover:not([readonly]):not([disabled]):not([focused])) [part='label'] {
       color: var(--lumo-secondary-text-color);
     }
   }

package/theme/lumo/vaadin-checkbox-group.d.ts

@@ -0,0 +1,3 @@
+import '@vaadin/checkbox/theme/lumo/vaadin-checkbox.js';
+import './vaadin-checkbox-group-styles.js';
+import '../../src/vaadin-checkbox-group.js';

package/theme/material/vaadin-checkbox-group-styles.d.ts

@@ -0,0 +1 @@
+import '@vaadin/vaadin-material-styles/color.js';

package/theme/material/vaadin-checkbox-group.d.ts

@@ -0,0 +1,3 @@
+import '@vaadin/checkbox/theme/material/vaadin-checkbox.js';
+import './vaadin-checkbox-group-styles.js';
+import '../../src/vaadin-checkbox-group.js';

package/web-types.json

@@ -0,0 +1,254 @@
+{
+  "$schema": "https://json.schemastore.org/web-types",
+  "name": "@vaadin/checkbox-group",
+  "version": "24.5.0-alpha1",
+  "description-markup": "markdown",
+  "contributions": {
+    "html": {
+      "elements": [
+        {
+          "name": "vaadin-checkbox-group",
+          "description": "`<vaadin-checkbox-group>` is a web component that allows the user to choose several items from a group of binary choices.\n\n```html\n<vaadin-checkbox-group label=\"Export data\">\n  <vaadin-checkbox value=\"0\" label=\"Order ID\"></vaadin-checkbox>\n  <vaadin-checkbox value=\"1\" label=\"Product name\"></vaadin-checkbox>\n  <vaadin-checkbox value=\"2\" label=\"Customer\"></vaadin-checkbox>\n  <vaadin-checkbox value=\"3\" label=\"Status\"></vaadin-checkbox>\n</vaadin-checkbox-group>\n```\n\n### Styling\n\nThe following shadow DOM parts are available for styling:\n\nPart name            | Description\n---------------------|----------------\n`label`              | The slotted label element wrapper\n`group-field`        | The checkbox elements wrapper\n`helper-text`        | The slotted helper text element wrapper\n`error-message`      | The slotted error message element wrapper\n`required-indicator` | The `required` state indicator element\n\nThe following state attributes are available for styling:\n\nAttribute           | Description                               | Part name\n--------------------|-------------------------------------------|------------\n`disabled`          | Set when the element is disabled          | :host\n`readonly`          | Set when the element is readonly          | :host\n`invalid`           | Set when the element is invalid           | :host\n`focused`           | Set when the element is focused           | :host\n`has-label`         | Set when the element has a label          | :host\n`has-value`         | Set when the element has a value          | :host\n`has-helper`        | Set when the element has helper text      | :host\n`has-error-message` | Set when the element has an error message | :host\n\nSee [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.",
+          "attributes": [
+            {
+              "name": "disabled",
+              "description": "If true, the user cannot interact with this element.",
+              "value": {
+                "type": [
+                  "boolean",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "label",
+              "description": "The label text for the input node.\nWhen no light dom defined via [slot=label], this value will be used.",
+              "value": {
+                "type": [
+                  "string",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "invalid",
+              "description": "Set to true when the field is invalid.",
+              "value": {
+                "type": [
+                  "boolean",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "required",
+              "description": "Specifies that the user must fill in a value.",
+              "value": {
+                "type": [
+                  "boolean",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "error-message",
+              "description": "Error to show when the field is invalid.",
+              "value": {
+                "type": [
+                  "string",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "helper-text",
+              "description": "String used for the helper text.",
+              "value": {
+                "type": [
+                  "string",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "accessible-name",
+              "description": "String used to label the component to screen reader users.",
+              "value": {
+                "type": [
+                  "string",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "accessible-name-ref",
+              "description": "Id of the element used as label of the component to screen reader users.",
+              "value": {
+                "type": [
+                  "string",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "readonly",
+              "description": "When true, the user cannot modify the value of the checkbox group.\nThe difference between `disabled` and `readonly` is that in the\nread-only checkbox group, all the checkboxes are also read-only,\nand therefore remain focusable and announced by screen readers.",
+              "value": {
+                "type": [
+                  "boolean",
+                  "null",
+                  "undefined"
+                ]
+              }
+            },
+            {
+              "name": "theme",
+              "description": "The theme variants to apply to the component.",
+              "value": {
+                "type": [
+                  "string",
+                  "null",
+                  "undefined"
+                ]
+              }
+            }
+          ],
+          "js": {
+            "properties": [
+              {
+                "name": "disabled",
+                "description": "If true, the user cannot interact with this element.",
+                "value": {
+                  "type": [
+                    "boolean",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "label",
+                "description": "The label text for the input node.\nWhen no light dom defined via [slot=label], this value will be used.",
+                "value": {
+                  "type": [
+                    "string",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "invalid",
+                "description": "Set to true when the field is invalid.",
+                "value": {
+                  "type": [
+                    "boolean",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "required",
+                "description": "Specifies that the user must fill in a value.",
+                "value": {
+                  "type": [
+                    "boolean",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "errorMessage",
+                "description": "Error to show when the field is invalid.",
+                "value": {
+                  "type": [
+                    "string",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "helperText",
+                "description": "String used for the helper text.",
+                "value": {
+                  "type": [
+                    "string",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "accessibleName",
+                "description": "String used to label the component to screen reader users.",
+                "value": {
+                  "type": [
+                    "string",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "accessibleNameRef",
+                "description": "Id of the element used as label of the component to screen reader users.",
+                "value": {
+                  "type": [
+                    "string",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              },
+              {
+                "name": "value",
+                "description": "An array containing values of the currently checked checkboxes.\n\nThe array is immutable so toggling checkboxes always results in\ncreating a new array.",
+                "value": {
+                  "type": [
+                    "Array.<string>"
+                  ]
+                }
+              },
+              {
+                "name": "readonly",
+                "description": "When true, the user cannot modify the value of the checkbox group.\nThe difference between `disabled` and `readonly` is that in the\nread-only checkbox group, all the checkboxes are also read-only,\nand therefore remain focusable and announced by screen readers.",
+                "value": {
+                  "type": [
+                    "boolean",
+                    "null",
+                    "undefined"
+                  ]
+                }
+              }
+            ],
+            "events": [
+              {
+                "name": "validated",
+                "description": "Fired whenever the field is validated."
+              },
+              {
+                "name": "invalid-changed",
+                "description": "Fired when the `invalid` property changes."
+              },
+              {
+                "name": "value-changed",
+                "description": "Fired when the `value` property changes."
+              }
+            ]
+          }
+        }
+      ]
+    }
+  }
+}

package/web-types.lit.json

@@ -0,0 +1,118 @@
+{
+  "$schema": "https://json.schemastore.org/web-types",
+  "name": "@vaadin/checkbox-group",
+  "version": "24.5.0-alpha1",
+  "description-markup": "markdown",
+  "framework": "lit",
+  "framework-config": {
+    "enable-when": {
+      "node-packages": [
+        "lit"
+      ]
+    }
+  },
+  "contributions": {
+    "html": {
+      "elements": [
+        {
+          "name": "vaadin-checkbox-group",
+          "description": "`<vaadin-checkbox-group>` is a web component that allows the user to choose several items from a group of binary choices.\n\n```html\n<vaadin-checkbox-group label=\"Export data\">\n  <vaadin-checkbox value=\"0\" label=\"Order ID\"></vaadin-checkbox>\n  <vaadin-checkbox value=\"1\" label=\"Product name\"></vaadin-checkbox>\n  <vaadin-checkbox value=\"2\" label=\"Customer\"></vaadin-checkbox>\n  <vaadin-checkbox value=\"3\" label=\"Status\"></vaadin-checkbox>\n</vaadin-checkbox-group>\n```\n\n### Styling\n\nThe following shadow DOM parts are available for styling:\n\nPart name            | Description\n---------------------|----------------\n`label`              | The slotted label element wrapper\n`group-field`        | The checkbox elements wrapper\n`helper-text`        | The slotted helper text element wrapper\n`error-message`      | The slotted error message element wrapper\n`required-indicator` | The `required` state indicator element\n\nThe following state attributes are available for styling:\n\nAttribute           | Description                               | Part name\n--------------------|-------------------------------------------|------------\n`disabled`          | Set when the element is disabled          | :host\n`readonly`          | Set when the element is readonly          | :host\n`invalid`           | Set when the element is invalid           | :host\n`focused`           | Set when the element is focused           | :host\n`has-label`         | Set when the element has a label          | :host\n`has-value`         | Set when the element has a value          | :host\n`has-helper`        | Set when the element has helper text      | :host\n`has-error-message` | Set when the element has an error message | :host\n\nSee [Styling Components](https://vaadin.com/docs/latest/styling/styling-components) documentation.",
+          "extension": true,
+          "attributes": [
+            {
+              "name": "?disabled",
+              "description": "If true, the user cannot interact with this element.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": "?invalid",
+              "description": "Set to true when the field is invalid.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": "?required",
+              "description": "Specifies that the user must fill in a value.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": "?readonly",
+              "description": "When true, the user cannot modify the value of the checkbox group.\nThe difference between `disabled` and `readonly` is that in the\nread-only checkbox group, all the checkboxes are also read-only,\nand therefore remain focusable and announced by screen readers.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": ".label",
+              "description": "The label text for the input node.\nWhen no light dom defined via [slot=label], this value will be used.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": ".errorMessage",
+              "description": "Error to show when the field is invalid.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": ".helperText",
+              "description": "String used for the helper text.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": ".accessibleName",
+              "description": "String used to label the component to screen reader users.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": ".accessibleNameRef",
+              "description": "Id of the element used as label of the component to screen reader users.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": ".value",
+              "description": "An array containing values of the currently checked checkboxes.\n\nThe array is immutable so toggling checkboxes always results in\ncreating a new array.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": "@validated",
+              "description": "Fired whenever the field is validated.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": "@invalid-changed",
+              "description": "Fired when the `invalid` property changes.",
+              "value": {
+                "kind": "expression"
+              }
+            },
+            {
+              "name": "@value-changed",
+              "description": "Fired when the `value` property changes.",
+              "value": {
+                "kind": "expression"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  }
+}