@vaadin/grid 24.3.0-alpha1 → 24.3.0-alpha10

package/src/vaadin-grid-sort-column-mixin.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright (c) 2016 - 2023 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 { GridSorterDirection } from './vaadin-grid-sorter.js';
+
+/**
+ * Fired when the `direction` property changes.
+ */
+export type GridSortColumnDirectionChangedEvent = CustomEvent<{ value: GridSorterDirection }>;
+
+export interface GridSortColumnCustomEventMap {
+  'direction-changed': GridSortColumnDirectionChangedEvent;
+}
+
+export interface GridSortColumnEventMap extends HTMLElementEventMap, GridSortColumnCustomEventMap {}
+
+export declare function GridSortColumnMixin<T extends Constructor<HTMLElement>>(
+  superclass: T,
+): Constructor<GridSortColumnMixinClass> & T;
+
+export declare class GridSortColumnMixinClass {
+  /**
+   * JS Path of the property in the item used for sorting the data.
+   */
+  path: string | null | undefined;
+
+  /**
+   * How to sort the data.
+   * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
+   * descending direction, or `null` for not sorting the data.
+   */
+  direction: GridSorterDirection | null | undefined;
+}

package/src/vaadin-grid-sort-column-mixin.js

@@ -0,0 +1,101 @@
+/**
+ * @license
+ * Copyright (c) 2016 - 2023 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+
+/**
+ * @polymerMixin
+ */
+export const GridSortColumnMixin = (superClass) =>
+  class extends superClass {
+    static get properties() {
+      return {
+        /**
+         * JS Path of the property in the item used for sorting the data.
+         */
+        path: {
+          type: String,
+          sync: true,
+        },
+
+        /**
+         * How to sort the data.
+         * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
+         * descending direction, or `null` for not sorting the data.
+         * @type {GridSorterDirection | undefined}
+         */
+        direction: {
+          type: String,
+          notify: true,
+          sync: true,
+        },
+      };
+    }
+
+    static get observers() {
+      return ['_onHeaderRendererOrBindingChanged(_headerRenderer, _headerCell, path, header, direction)'];
+    }
+
+    constructor() {
+      super();
+
+      this.__boundOnDirectionChanged = this.__onDirectionChanged.bind(this);
+    }
+
+    /**
+     * Renders the grid sorter to the header cell.
+     *
+     * @override
+     */
+    _defaultHeaderRenderer(root, _column) {
+      let sorter = root.firstElementChild;
+      if (!sorter) {
+        sorter = document.createElement('vaadin-grid-sorter');
+        sorter.addEventListener('direction-changed', this.__boundOnDirectionChanged);
+        root.appendChild(sorter);
+      }
+
+      sorter.path = this.path;
+      sorter.__rendererDirection = this.direction;
+      sorter.direction = this.direction;
+      sorter.textContent = this.__getHeader(this.header, this.path);
+    }
+
+    /**
+     * The sort column doesn't allow to use a custom header renderer
+     * to override the header cell content.
+     * It always renders the grid sorter to the header cell.
+     *
+     * @override
+     */
+    _computeHeaderRenderer() {
+      return this._defaultHeaderRenderer;
+    }
+
+    /**
+     * Updates the sorting direction once the grid sorter's direction is changed.
+     * The listener handles only user-fired events.
+     *
+     * @private
+     */
+    __onDirectionChanged(e) {
+      // Skip if the direction is changed by the renderer.
+      if (e.detail.value === e.target.__rendererDirection) {
+        return;
+      }
+
+      this.direction = e.detail.value;
+    }
+
+    /** @private */
+    __getHeader(header, path) {
+      if (header) {
+        return header;
+      }
+
+      if (path) {
+        return this._generateHeader(path);
+      }
+    }
+  };

package/src/vaadin-grid-sort-column.d.ts

@@ -4,19 +4,10 @@
  * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
  */
 import type { GridDefaultItem } from './vaadin-grid.js';
-import { GridColumn } from './vaadin-grid-column.js';
-import type { GridSorterDirection } from './vaadin-grid-sorter.js';
+import type { GridColumn, GridColumnMixin } from './vaadin-grid-column.js';
+import type { GridSortColumnEventMap, GridSortColumnMixinClass } from './vaadin-grid-sort-column-mixin.js';
 
-/**
- * Fired when the `direction` property changes.
- */
-export type GridSortColumnDirectionChangedEvent = CustomEvent<{ value: GridSorterDirection }>;
-
-export interface GridSortColumnCustomEventMap {
-  'direction-changed': GridSortColumnDirectionChangedEvent;
-}
-
-export interface GridSortColumnEventMap extends HTMLElementEventMap, GridSortColumnCustomEventMap {}
+export * from './vaadin-grid-sort-column-mixin.js';
 
 /**
  * `<vaadin-grid-sort-column>` is a helper element for the `<vaadin-grid>`
@@ -30,22 +21,13 @@ export interface GridSortColumnEventMap extends HTMLElementEventMap, GridSortCol
  *  <vaadin-grid-column>
  *    ...
  * ```
- *
- * @fires {CustomEvent} direction-changed - Fired when the `direction` property changes.
  */
-declare class GridSortColumn<TItem = GridDefaultItem> extends GridColumn<TItem> {
-  /**
-   * JS Path of the property in the item used for sorting the data.
-   */
-  path: string | null | undefined;
-
-  /**
-   * How to sort the data.
-   * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
-   * descending direction, or `null` for not sorting the data.
-   */
-  direction: GridSorterDirection | null | undefined;
+declare class GridSortColumn<TItem = GridDefaultItem> extends HTMLElement {}
 
+interface GridSortColumn<TItem = GridDefaultItem>
+  extends GridSortColumnMixinClass,
+    GridColumnMixin<TItem, GridColumn<TItem>>,
+    GridColumn<TItem> {
   addEventListener<K extends keyof GridSortColumnEventMap>(
     type: K,
     listener: (this: GridSortColumn<TItem>, ev: GridSortColumnEventMap[K]) => void,

package/src/vaadin-grid-sort-column.js

@@ -6,6 +6,7 @@
 import './vaadin-grid-sorter.js';
 import { defineCustomElement } from '@vaadin/component-base/src/define.js';
 import { GridColumn } from './vaadin-grid-column.js';
+import { GridSortColumnMixin } from './vaadin-grid-sort-column-mixin.js';
 
 /**
  * `<vaadin-grid-sort-column>` is a helper element for the `<vaadin-grid>`
@@ -24,97 +25,12 @@ import { GridColumn } from './vaadin-grid-column.js';
  *
  * @customElement
  * @extends GridColumn
+ * @mixes GridSortColumnMixin
  */
-class GridSortColumn extends GridColumn {
+class GridSortColumn extends GridSortColumnMixin(GridColumn) {
   static get is() {
     return 'vaadin-grid-sort-column';
   }
-
-  static get properties() {
-    return {
-      /**
-       * JS Path of the property in the item used for sorting the data.
-       */
-      path: String,
-
-      /**
-       * How to sort the data.
-       * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
-       * descending direction, or `null` for not sorting the data.
-       * @type {GridSorterDirection | undefined}
-       */
-      direction: {
-        type: String,
-        notify: true,
-      },
-    };
-  }
-
-  static get observers() {
-    return ['_onHeaderRendererOrBindingChanged(_headerRenderer, _headerCell, path, header, direction)'];
-  }
-
-  constructor() {
-    super();
-
-    this.__boundOnDirectionChanged = this.__onDirectionChanged.bind(this);
-  }
-
-  /**
-   * Renders the grid sorter to the header cell.
-   *
-   * @override
-   */
-  _defaultHeaderRenderer(root, _column) {
-    let sorter = root.firstElementChild;
-    if (!sorter) {
-      sorter = document.createElement('vaadin-grid-sorter');
-      sorter.addEventListener('direction-changed', this.__boundOnDirectionChanged);
-      root.appendChild(sorter);
-    }
-
-    sorter.path = this.path;
-    sorter.__rendererDirection = this.direction;
-    sorter.direction = this.direction;
-    sorter.textContent = this.__getHeader(this.header, this.path);
-  }
-
-  /**
-   * The sort column doesn't allow to use a custom header renderer
-   * to override the header cell content.
-   * It always renders the grid sorter to the header cell.
-   *
-   * @override
-   */
-  _computeHeaderRenderer() {
-    return this._defaultHeaderRenderer;
-  }
-
-  /**
-   * Updates the sorting direction once the grid sorter's direction is changed.
-   * The listener handles only user-fired events.
-   *
-   * @private
-   */
-  __onDirectionChanged(e) {
-    // Skip if the direction is changed by the renderer.
-    if (e.detail.value === e.target.__rendererDirection) {
-      return;
-    }
-
-    this.direction = e.detail.value;
-  }
-
-  /** @private */
-  __getHeader(header, path) {
-    if (header) {
-      return header;
-    }
-
-    if (path) {
-      return this._generateHeader(path);
-    }
-  }
 }
 
 defineCustomElement(GridSortColumn);

package/src/vaadin-grid-sorter-mixin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright (c) 2016 - 2023 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';
+
+export type GridSorterDirection = 'asc' | 'desc' | null;
+
+/**
+ * Fired when the `path` or `direction` property changes.
+ */
+export type GridSorterChangedEvent = CustomEvent<{ shiftClick: boolean; fromSorterClick: boolean }>;
+
+/**
+ * Fired when the `direction` property changes.
+ */
+export type GridSorterDirectionChangedEvent = CustomEvent<{ value: GridSorterDirection }>;
+
+export interface GridSorterCustomEventMap {
+  'sorter-changed': GridSorterChangedEvent;
+
+  'direction-changed': GridSorterDirectionChangedEvent;
+}
+
+export interface GridSorterEventMap extends HTMLElementEventMap, GridSorterCustomEventMap {}
+
+export declare function GridSorterMixin<T extends Constructor<HTMLElement>>(
+  base: T,
+): Constructor<GridSorterMixinClass> & T;
+
+declare class GridSorterMixinClass {
+  /**
+   * JS Path of the property in the item used for sorting the data.
+   */
+  path: string | null | undefined;
+
+  /**
+   * How to sort the data.
+   * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
+   * descending direction, or `null` for not sorting the data.
+   */
+  direction: GridSorterDirection | null | undefined;
+}

package/src/vaadin-grid-sorter-mixin.js

@@ -0,0 +1,200 @@
+/**
+ * @license
+ * Copyright (c) 2016 - 2023 Vaadin Ltd.
+ * This program is available under Apache License Version 2.0, available at https://vaadin.com/license/
+ */
+import { css, registerStyles } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+
+const template = document.createElement('template');
+
+template.innerHTML = `
+  <style>
+    @font-face {
+      font-family: 'vaadin-grid-sorter-icons';
+      src: url(data:application/font-woff;charset=utf-8;base64,d09GRgABAAAAAAQwAA0AAAAABuwAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABGRlRNAAAEFAAAABkAAAAcfep+mUdERUYAAAP4AAAAHAAAAB4AJwAOT1MvMgAAAZgAAAA/AAAAYA8TBPpjbWFwAAAB7AAAAFUAAAFeF1fZ4mdhc3AAAAPwAAAACAAAAAgAAAAQZ2x5ZgAAAlgAAABcAAAAnMvguMloZWFkAAABMAAAAC8AAAA2C5Ap72hoZWEAAAFgAAAAHQAAACQGbQPHaG10eAAAAdgAAAAUAAAAHAoAAABsb2NhAAACRAAAABIAAAASAIwAYG1heHAAAAGAAAAAFgAAACAACwAKbmFtZQAAArQAAAECAAACZxWCgKhwb3N0AAADuAAAADUAAABZCrApUXicY2BkYGAA4rDECVrx/DZfGbhZGEDgyqNPOxH0/wNMq5kPALkcDEwgUQBWRA0dAHicY2BkYGA+8P8AAwMLAwgwrWZgZEAFbABY4QM8AAAAeJxjYGRgYOAAQiYGEICQSAAAAi8AFgAAeJxjYGY6yziBgZWBgWkm0xkGBoZ+CM34msGYkZMBFTAKoAkwODAwvmRiPvD/AIMDMxCD1CDJKjAwAgBktQsXAHicY2GAAMZQCM0EwqshbAALxAEKeJxjYGBgZoBgGQZGBhCIAPIYwXwWBhsgzcXAwcAEhIwMCi+Z/v/9/x+sSuElA4T9/4k4K1gHFwMMMILMY2QDYmaoABOQYGJABUA7WBiGNwAAJd4NIQAAAAAAAAAACAAIABAAGAAmAEAATgAAeJyNjLENgDAMBP9tIURJwQCMQccSZgk2i5fIYBDAidJjycXr7x5EPwE2wY8si7jmyBNXGo/bNBerxJNrpxhbO3/fEFpx8ZICpV+ghxJ74fAMe+h7Ox14AbrsHB14nK2QQWrDMBRER4mTkhQK3ZRQKOgCNk7oGQqhhEIX2WSlWEI1BAlkJ5CDdNsj5Ey9Rncdi38ES+jzNJo/HwTgATcoDEthhY3wBHc4CE+pfwsX5F/hGe7Vo/AcK/UhvMSz+mGXKhZU6pww8ISz3oWn1BvhgnwTnuEJf8Jz1OpFeIlX9YULDLdFi4ASHolkSR0iuYdjLak1vAequBhj21D61Nqyi6l3qWybGPjySbPHGScGJl6dP58MYcQRI0bts7mjebBqrFENH7t3qWtj0OuqHnXcW7b0HOTZFnKryRGW2hFX1m0O2vEM3opNMfTau+CS6Z3Vx6veNnEXY6jwDxhsc2gAAHicY2BiwA84GBgYmRiYGJkZmBlZGFkZ2djScyoLMgzZS/MyDQwMwLSrpYEBlIbxjQDrzgsuAAAAAAEAAf//AA94nGNgZGBg4AFiMSBmYmAEQnYgZgHzGAAD6wA2eJxjYGBgZACCKyoz1cD0o087YTQATOcIewAAAA==) format('woff');
+      font-weight: normal;
+      font-style: normal;
+    }
+  </style>
+`;
+
+document.head.appendChild(template.content);
+
+registerStyles(
+  'vaadin-grid-sorter',
+  css`
+    :host {
+      display: inline-flex;
+      cursor: pointer;
+      max-width: 100%;
+    }
+
+    [part='content'] {
+      flex: 1 1 auto;
+    }
+
+    [part='indicators'] {
+      position: relative;
+      align-self: center;
+      flex: none;
+    }
+
+    [part='order'] {
+      display: inline;
+      vertical-align: super;
+    }
+
+    [part='indicators']::before {
+      font-family: 'vaadin-grid-sorter-icons';
+      display: inline-block;
+    }
+
+    :host(:not([direction])) [part='indicators']::before {
+      content: '\\e901';
+    }
+
+    :host([direction='asc']) [part='indicators']::before {
+      content: '\\e900';
+    }
+
+    :host([direction='desc']) [part='indicators']::before {
+      content: '\\e902';
+    }
+  `,
+  { moduleId: 'vaadin-grid-sorter-styles' },
+);
+
+/**
+ * A mixin providing common sorter functionality.
+ *
+ * @polymerMixin
+ */
+export const GridSorterMixin = (superClass) =>
+  class GridSorterMixinClass extends superClass {
+    static get properties() {
+      return {
+        /**
+         * JS Path of the property in the item used for sorting the data.
+         */
+        path: String,
+
+        /**
+         * How to sort the data.
+         * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
+         * descending direction, or `null` for not sorting the data.
+         * @type {GridSorterDirection | undefined}
+         */
+        direction: {
+          type: String,
+          reflectToAttribute: true,
+          notify: true,
+          value: null,
+          sync: true,
+        },
+
+        /**
+         * @type {number | null}
+         * @protected
+         */
+        _order: {
+          type: Number,
+          value: null,
+          sync: true,
+        },
+
+        /** @private */
+        _isConnected: {
+          type: Boolean,
+          observer: '__isConnectedChanged',
+        },
+      };
+    }
+
+    static get observers() {
+      return ['_pathOrDirectionChanged(path, direction)'];
+    }
+
+    /** @protected */
+    ready() {
+      super.ready();
+      this.addEventListener('click', this._onClick.bind(this));
+    }
+
+    /** @protected */
+    connectedCallback() {
+      super.connectedCallback();
+      this._isConnected = true;
+    }
+
+    /** @protected */
+    disconnectedCallback() {
+      super.disconnectedCallback();
+      this._isConnected = false;
+
+      if (!this.parentNode && this._grid) {
+        this._grid.__removeSorters([this]);
+      }
+    }
+
+    /** @private */
+    _pathOrDirectionChanged() {
+      this.__dispatchSorterChangedEvenIfPossible();
+    }
+
+    /** @private */
+    __isConnectedChanged(newValue, oldValue) {
+      if (oldValue === false) {
+        return;
+      }
+
+      this.__dispatchSorterChangedEvenIfPossible();
+    }
+
+    /** @private */
+    __dispatchSorterChangedEvenIfPossible() {
+      if (this.path === undefined || this.direction === undefined || !this._isConnected) {
+        return;
+      }
+
+      this.dispatchEvent(
+        new CustomEvent('sorter-changed', {
+          detail: { shiftClick: Boolean(this._shiftClick), fromSorterClick: Boolean(this._fromSorterClick) },
+          bubbles: true,
+          composed: true,
+        }),
+      );
+      // Cleaning up as a programatically sorting can be done after some user interaction
+      this._fromSorterClick = false;
+      this._shiftClick = false;
+    }
+
+    /** @private */
+    _getDisplayOrder(order) {
+      return order === null ? '' : order + 1;
+    }
+
+    /** @private */
+    _onClick(e) {
+      if (e.defaultPrevented) {
+        // Something else has already handled the click event, do nothing.
+        return;
+      }
+
+      const activeElement = this.getRootNode().activeElement;
+      if (this !== activeElement && this.contains(activeElement)) {
+        // Some focusable content inside the sorter was clicked, do nothing.
+        return;
+      }
+
+      e.preventDefault();
+      this._shiftClick = e.shiftKey;
+      this._fromSorterClick = true;
+      if (this.direction === 'asc') {
+        this.direction = 'desc';
+      } else if (this.direction === 'desc') {
+        this.direction = null;
+      } else {
+        this.direction = 'asc';
+      }
+    }
+  };

package/src/vaadin-grid-sorter.d.ts

@@ -5,26 +5,9 @@
  */
 import { DirMixin } from '@vaadin/component-base/src/dir-mixin.js';
 import { ThemableMixin } from '@vaadin/vaadin-themable-mixin/vaadin-themable-mixin.js';
+import { type GridSorterEventMap, GridSorterMixin } from './vaadin-grid-sorter-mixin.js';
 
-export type GridSorterDirection = 'asc' | 'desc' | null;
-
-/**
- * Fired when the `path` or `direction` property changes.
- */
-export type GridSorterChangedEvent = CustomEvent<{ shiftClick: boolean; fromSorterClick: boolean }>;
-
-/**
- * Fired when the `direction` property changes.
- */
-export type GridSorterDirectionChangedEvent = CustomEvent<{ value: GridSorterDirection }>;
-
-export interface GridSorterCustomEventMap {
-  'sorter-changed': GridSorterChangedEvent;
-
-  'direction-changed': GridSorterDirectionChangedEvent;
-}
-
-export interface GridSorterEventMap extends HTMLElementEventMap, GridSorterCustomEventMap {}
+export * from './vaadin-grid-sorter-mixin.js';
 
 /**
  * `<vaadin-grid-sorter>` is a helper element for the `<vaadin-grid>` that provides out-of-the-box UI controls,
@@ -65,19 +48,7 @@ export interface GridSorterEventMap extends HTMLElementEventMap, GridSorterCusto
  * @fires {CustomEvent} direction-changed - Fired when the `direction` property changes.
  * @fires {CustomEvent} sorter-changed - Fired when the `path` or `direction` property changes.
  */
-declare class GridSorter extends ThemableMixin(DirMixin(HTMLElement)) {
-  /**
-   * JS Path of the property in the item used for sorting the data.
-   */
-  path: string | null | undefined;
-
-  /**
-   * How to sort the data.
-   * Possible values are `asc` to use an ascending algorithm, `desc` to sort the data in
-   * descending direction, or `null` for not sorting the data.
-   */
-  direction: GridSorterDirection | null | undefined;
-
+declare class GridSorter extends GridSorterMixin(ThemableMixin(DirMixin(HTMLElement))) {
   addEventListener<K extends keyof GridSorterEventMap>(
     type: K,
     listener: (this: GridSorter, ev: GridSorterEventMap[K]) => void,