@fusion.dev/helix-headless 0.144.0 → 0.146.0

package/dist/tabs/panel/tab-panel.d.ts

@@ -8,6 +8,13 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * still there when the person comes back, and the content of every panel is in
  * the server-rendered markup for crawlers, whichever tab is open.
  *
+ * The host is the `tabpanel` while its tab is selected, through
+ * `ElementInternals`, so the tab's `aria-controls` can reach it from the tab's
+ * shadow root. The box inside is a tab stop only while the panel holds nothing
+ * focusable, as the ARIA tabs pattern and React Aria's tab panel do: Tab from
+ * the tab list lands on the panel's first link or control where there is one,
+ * and on the panel itself where there is none.
+ *
  * @since 0.1.0
  * @status stable
  * @aliases TabPanel
@@ -15,7 +22,7 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  *
  * @slot - The panel's content.
  *
- * @csspart panel - The panel container.
+ * @csspart panel - The panel container, which takes the focus while it holds nothing focusable.
  *
  * @cssstate selected - While its tab is the one selected.
  */
@@ -28,10 +35,9 @@ export declare class HelixHeadlessTabPanel extends HelixElement {
      * writes: the tab already says it.
      *
      * A string and not a reference: an IDREF resolves only in the tree it is
-     * written in, and an element reference cannot reach a sibling shadow tree
-     * either, so `aria-labelledby` to the tab's own id leaves the panel with no
-     * accessible name. `aria-label` on a `tabpanel` is how the pattern names one
-     * anyway.
+     * written in, and the tab's control is inside the tab's shadow root, which no
+     * reference from the light DOM can reach. `aria-label` on a `tabpanel` is how
+     * the pattern names one anyway.
      */
     label: string;
     /**
@@ -42,6 +48,17 @@ export declare class HelixHeadlessTabPanel extends HelixElement {
      * Pairs the panel with the tab of the same value.
      */
     value: string;
+    /**
+     * Whether the content holds a tab stop of its own, so the panel needs none.
+     * False on a server, which serves the panel as a stop: it cannot look.
+     */
+    private holdsStop;
+    /** Re-reads the content when it changes in a way that adds or removes a stop. */
+    private readonly watcher;
+    private readonly readStops;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    protected updated(changed: PropertyValues): void;
     /**
      * Mirrors the chosen state where a stylesheet can select on it.
      *

package/dist/tabs/panel/tab-panel.js

@@ -4,29 +4,54 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement } from '@fusion.dev/helix-core';
+import { customElement, focusableElements, HelixElement, hostAria } from '@fusion.dev/helix-core';
 import { html, nothing } from 'lit';
-import { property } from 'lit/decorators.js';
+import { property, state } from 'lit/decorators.js';
 let HelixHeadlessTabPanel = class HelixHeadlessTabPanel extends HelixElement {
     constructor() {
         super(...arguments);
         this.label = '';
         this.selected = false;
         this.value = '';
+        this.holdsStop = false;
+        this.watcher = typeof MutationObserver === 'undefined'
+            ? undefined
+            : new MutationObserver(() => this.readStops());
+        this.readStops = () => {
+            this.holdsStop = this.selected && focusableElements(this).length > 0;
+        };
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.watcher?.observe(this, {
+            attributeFilter: ['contenteditable', 'disabled', 'hidden', 'href', 'tabindex'],
+            attributes: true,
+            childList: true,
+            subtree: true,
+        });
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.watcher?.disconnect();
+    }
+    updated(changed) {
+        super.updated(changed);
+        if (changed.has('selected')) {
+            this.readStops();
+        }
     }
     willUpdate(changed) {
         super.willUpdate(changed);
         this.toggleState('selected', this.selected);
+        hostAria(this.internals, { label: this.label, role: this.selected ? 'tabpanel' : '' });
     }
     render() {
         return html `<div
       part="panel"
-      role="tabpanel"
-      aria-label=${this.label || nothing}
       ?hidden=${!this.selected}
-      tabindex="0"
+      tabindex=${this.holdsStop ? nothing : '0'}
     >
-      <slot></slot>
+      <slot @slotchange=${this.readStops}></slot>
     </div>`;
     }
 };
@@ -39,6 +64,9 @@ __decorate([
 __decorate([
     property()
 ], HelixHeadlessTabPanel.prototype, "value", void 0);
+__decorate([
+    state()
+], HelixHeadlessTabPanel.prototype, "holdsStop", void 0);
 HelixHeadlessTabPanel = __decorate([
     customElement('helix-headless-tab-panel')
 ], HelixHeadlessTabPanel);

package/dist/tabs/root/tabs-root.d.ts

@@ -16,6 +16,29 @@ declare const HelixHeadlessTabs_base: (new (...args: any[]) => import("@fusion.d
  * panel is cheap. Set `manual` when showing a panel is expensive, so focus can
  * move without selecting.
  *
+ * `orientation="vertical"` sets the tabs in a column beside the panels, and the
+ * tab list says `aria-orientation="vertical"`. The arrow keys of both axes move
+ * between tabs either way.
+ *
+ * A tab with an `href` is a link, for tabs that are pages of a site. Pressing
+ * it follows the link, and the arrow keys move focus without choosing, so
+ * arrowing past a tab never leaves the page. Mark the tab of the page you are
+ * on with `selected`, or set `active` to its value.
+ *
+ * Each tab says which panel it controls through `aria-controls`, set as an
+ * element reference to the panel's host, where the engine has reflection.
+ *
+ * Keys, on the tab list: Left and Right Arrow move between tabs, and so do Up
+ * and Down; Home and End go to the first and the last. The horizontal arrows
+ * follow the reading direction, so on a right-to-left page Left moves on.
+ * Disabled tabs are passed over. Tab leaves the list for the selected panel,
+ * which is a tab stop only while it holds nothing focusable.
+ *
+ * The `indicator` part moves to the selected tab and carries its place and
+ * size, so a mark of your own can be drawn there: style the part, or slot an
+ * element into `indicator`, which sits inside the part and reads the same
+ * properties.
+ *
  * @since 0.1.0
  * @status stable
  * @category navigation
@@ -23,13 +46,17 @@ declare const HelixHeadlessTabs_base: (new (...args: any[]) => import("@fusion.d
  * @documentation https://fusion.dev/helix/components/tabs
  *
  * @slot - The tabs, as direct children of this element.
+ * @slot indicator - A mark of your own, drawn inside the `indicator` part, where `--indicator-x`, `--indicator-y`, `--indicator-inline-size` and `--indicator-block-size` reach it.
  * @slot panels - The panels, as direct children of this element. Panels inside a wrapper are not paired with tabs, because pairing reads only the direct children.
  *
  * @event {HelixActivateEvent} helix-activate - Fired after the active tab changes, so the element already holds the new value.
  * @event {HelixBeforeActivateEvent} helix-before-activate - Fired before the active tab changes, and cancelable. Canceling it is the only way to block a change.
  * @event {HelixSelectEvent} helix-select - Fired when a tab is chosen. The tab sends it and the root handles it, so you can listen on the root. Cancelable: canceling it stops the change and leaves the decision to you.
  *
- * @csspart indicator - The marker that moves to the selected tab.
+ * @csspart indicator - The marker that moves to the selected tab. It carries the selected tab's
+ *   place and size as `--indicator-x`, `--indicator-y`, `--indicator-inline-size` and
+ *   `--indicator-block-size`, and `data-placed` once it has been placed, for a mark you draw
+ *   and animate yourself.
  * @csspart panels - The panel container.
  * @csspart tabs - The tab list.
  */
@@ -54,6 +81,13 @@ export declare class HelixHeadlessTabs extends HelixHeadlessTabs_base {
      * panels on the way.
      */
     manual: boolean;
+    /**
+     * The direction the tabs run. `vertical` sets them in a column beside the
+     * panels and tells a screen reader the list is vertical.
+     *
+     * Optional, so the resting row writes no attribute onto the host.
+     */
+    orientation?: 'horizontal' | 'vertical';
     /**
      * How the row of tabs is drawn.
      *
@@ -80,6 +114,8 @@ export declare class HelixHeadlessTabs extends HelixHeadlessTabs_base {
      */
     variant?: 'segmented' | 'underlined';
     private get tabs();
+    /** Whether any tab is a link, so arriving on one chooses nothing. */
+    private get linked();
     private get panels();
     private readonly handleSelection;
     /** Pushes the current value down to whichever tab and panel own it. */

package/dist/tabs/root/tabs-root.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { AriaForwardController, customElement, HelixElement, IndicatorController, KeyboardNavigationController, MixinControllerActive, whenHydrated, } from '@fusion.dev/helix-core';
-import { html } from 'lit';
+import { html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { HelixHeadlessTabPanel } from '../panel/tab-panel.js';
 import { HelixHeadlessTab } from '../tab/tab.js';
@@ -15,7 +15,7 @@ let HelixHeadlessTabs = class HelixHeadlessTabs extends MixinControllerActive(He
         this.keys = new KeyboardNavigationController(this, {
             items: () => this.tabs,
             origin: 'focus',
-            selects: () => !this.manual,
+            selects: () => !this.manual && !this.linked,
         });
         this.indicator = new IndicatorController(this, {
             active: () => this.tabs.find((tab) => tab.selected),
@@ -43,6 +43,9 @@ let HelixHeadlessTabs = class HelixHeadlessTabs extends MixinControllerActive(He
     get tabs() {
         return [...this.children].filter((child) => child instanceof HelixHeadlessTab);
     }
+    get linked() {
+        return this.tabs.some((tab) => (tab.href ?? '') !== '');
+    }
     get panels() {
         return [...this.children].filter((child) => child instanceof HelixHeadlessTabPanel);
     }
@@ -57,6 +60,13 @@ let HelixHeadlessTabs = class HelixHeadlessTabs extends MixinControllerActive(He
             });
         }
         const names = new Map(tabs.map((tab) => [tab.value, (tab.textContent ?? '').trim()]));
+        const panels = new Map(this.panels.map((panel) => [panel.value, panel]));
+        for (const tab of tabs) {
+            const panel = panels.get(tab.value);
+            whenHydrated(tab, () => {
+                tab.controls = panel;
+            });
+        }
         for (const panel of this.panels) {
             const selected = panel.value === value;
             const label = names.get(panel.value) ?? '';
@@ -88,9 +98,14 @@ let HelixHeadlessTabs = class HelixHeadlessTabs extends MixinControllerActive(He
         this.indicator.place();
     }
     render() {
-        return html `<div part="tabs" role="tablist" aria-label=${this.label}>
+        return html `<div
+        part="tabs"
+        role="tablist"
+        aria-label=${this.label}
+        aria-orientation=${this.orientation === 'vertical' ? 'vertical' : nothing}
+      >
         <slot @slotchange=${this.handleSlotChange}></slot>
-        <span part="indicator" aria-hidden="true"></span>
+        <span part="indicator" aria-hidden="true"><slot name="indicator"></slot></span>
       </div>
       <div part="panels"><slot name="panels" @slotchange=${this.handleSlotChange}></slot></div>`;
     }
@@ -101,6 +116,9 @@ __decorate([
 __decorate([
     property({ reflect: true, type: Boolean })
 ], HelixHeadlessTabs.prototype, "manual", void 0);
+__decorate([
+    property({ reflect: true })
+], HelixHeadlessTabs.prototype, "orientation", void 0);
 __decorate([
     property({ reflect: true })
 ], HelixHeadlessTabs.prototype, "variant", void 0);

package/dist/tabs/tab/tab.d.ts

@@ -7,10 +7,10 @@ declare const HelixHeadlessTab_base: (new (...args: any[]) => import("@fusion.de
  * @description
  * A tab is an element, because it manages selection and its own tab stop.
  *
- * Its id and the id it controls both come from `value`, so the link between a
- * tab and its panel works with server rendering. A generated id would differ
- * between the server render and the client render, and `aria-controls` would
- * point at nothing.
+ * With an `href`, the tab is a link: `role="tab"` on an `<a>`, which a press,
+ * Enter and the browser's own link gestures follow. `helix-select` is sent
+ * first, and canceling it keeps the browser from following, so a client-side
+ * router follows it instead.
  *
  * @since 0.1.0
  * @status stable
@@ -27,6 +27,43 @@ declare const HelixHeadlessTab_base: (new (...args: any[]) => import("@fusion.de
  */
 export declare class HelixHeadlessTab extends HelixHeadlessTab_base {
     protected itemPart: string;
+    /**
+     * @internal The panel this tab shows, written by the tab set. A property,
+     * because it is an element, and it reaches the tab's `aria-controls` as an
+     * element reference: the panel is in the light DOM, which a reference from
+     * inside this shadow root can reach.
+     */
+    controls: Element | undefined;
+    /**
+     * The URL the tab links to. Setting it renders the tab as a link, for a set
+     * of tabs that are pages of a site.
+     */
+    href?: string;
+    /**
+     * The link's `rel`, for a tab with an `href`.
+     */
+    rel?: string;
+    /**
+     * Where the link opens, such as `_blank`, for a tab with an `href`.
+     */
+    target?: string;
+    /**
+     * Moves focus to the tab's control, the button or the link inside it, so a
+     * script can focus the tab the way it focuses a native one.
+     */
+    focus(options?: FocusOptions): void;
+    /**
+     * Chooses the tab before the browser follows its link, and keeps the browser
+     * from following where the choice was refused. A press with a modifier, or
+     * with a button other than the main one, opens the link where the browser
+     * opens it and chooses nothing here.
+     */
+    private readonly handleLinkClick;
+    /**
+     * Points the control's `aria-controls` at the panel, where the engine can.
+     * The control is this tab's own, so the reference is always its to clear.
+     */
+    protected updated(changed: PropertyValues): void;
     /**
      * Asks for the render that follows a hydration, so the stop stops being every
      * tab's.

package/dist/tabs/tab/tab.js

@@ -4,31 +4,77 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { customElement, HelixElement, MixinSelectableItem } from '@fusion.dev/helix-core';
-import { html } from 'lit';
+import { customElement, HelixElement, MixinSelectableItem, plainClick, reflectElements, } from '@fusion.dev/helix-core';
+import { html, nothing } from 'lit';
+import { property } from 'lit/decorators.js';
 let HelixHeadlessTab = class HelixHeadlessTab extends MixinSelectableItem(HelixElement) {
     constructor() {
         super(...arguments);
         this.itemPart = 'tab';
+        this.controls = undefined;
+        this.handleLinkClick = (event) => {
+            if (!plainClick(event)) {
+                return;
+            }
+            if (!this.select()) {
+                event.preventDefault();
+            }
+        };
+    }
+    focus(options) {
+        this.partNamed('tab')?.focus(options);
+    }
+    updated(changed) {
+        super.updated(changed);
+        const control = this.renderRoot.querySelector('[part="tab"]');
+        reflectElements(control, 'ariaControlsElements', this.controls ? [this.controls] : [], true);
     }
     firstUpdated(changed) {
         super.firstUpdated(changed);
         this.finishHydration();
     }
     render() {
+        const tabindex = this.selected || !this.childrenKnown ? '0' : '-1';
+        if ((this.href ?? '') !== '') {
+            return html `<a
+        part="tab"
+        role="tab"
+        href=${this.disabled ? nothing : (this.href ?? nothing)}
+        target=${this.target || nothing}
+        rel=${this.rel || nothing}
+        aria-selected=${this.selected ? 'true' : 'false'}
+        aria-disabled=${this.disabled ? 'true' : nothing}
+        tabindex=${this.disabled ? nothing : tabindex}
+        @click=${this.handleLinkClick}
+      >
+        <slot></slot>
+      </a>`;
+        }
         return html `<button
       part="tab"
       role="tab"
       type="button"
       aria-selected=${this.selected ? 'true' : 'false'}
       ?disabled=${this.disabled}
-      tabindex=${this.selected || !this.childrenKnown ? '0' : '-1'}
+      tabindex=${tabindex}
       @click=${() => this.select()}
     >
       <slot></slot>
     </button>`;
     }
 };
+__decorate([
+    property({ attribute: false })
+], HelixHeadlessTab.prototype, "controls", void 0);
+__decorate([
+    property()
+], HelixHeadlessTab.prototype, "href", void 0);
+__decorate([
+    property()
+], HelixHeadlessTab.prototype, "rel", void 0);
+__decorate([
+    property()
+], HelixHeadlessTab.prototype, "target", void 0);
 HelixHeadlessTab = __decorate([
     customElement('helix-headless-tab')
 ], HelixHeadlessTab);

package/dist/tag/group/tag-group.d.ts

@@ -1,7 +1,8 @@
-import { HelixElement, KeyboardNavigationController } from '@fusion.dev/helix-core';
+import { HelixElement, KeyboardNavigationController, type SelectionMode } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 import { HelixHeadlessTag } from '../root/tag-root.js';
-import { type TagSelectionMode } from '../selection.js';
+/** How many tags a group lets a reader select: core's `SelectionMode`. */
+export type TagSelectionMode = SelectionMode;
 /**
  * @summary A set of tags that the arrow keys move through, and that can be removed and selected from the keyboard.
  *
@@ -17,9 +18,16 @@ import { type TagSelectionMode } from '../selection.js';
  * `single` selects one at a time and `multiple` any number. `value` holds the
  * selected tags' values, separated by commas, and a change asks with
  * `helix-before-change` and tells with `change`. Enter on a tag with an
- * `href` follows its link. A `disabled` tag is passed over.
+ * `href` follows its link. A `disabled` tag is passed over. A selected tag
+ * that is removed leaves `value`, which then sends `change`.
  *
- * Name the set with `label`.
+ * Name the set with `label`. Each tag is named by its words alone, without
+ * its remove button.
+ *
+ * **Removing the last tag keeps focus in the group.** With no tags left the
+ * set is a `group`, and focus moves to its `empty` part,
+ * which holds the `empty` slot: put words there such as "No filters" for a
+ * reader to hear.
  *
  * @since 0.1.0
  * @status stable
@@ -27,10 +35,13 @@ import { type TagSelectionMode } from '../selection.js';
  * @documentation https://fusion.dev/helix/components/tag
  *
  * @slot - The tags, in the order they are read.
+ * @slot empty - Shown in place of the tags while there are none, such as "No filters".
  *
  * @event {Event} change - Fired once a press has changed which tags are selected.
  * @event {HelixBeforeChangeEvent} helix-before-change - Fired before a press changes which tags are selected, with the `value` it would leave. Cancelable.
  * @event {HelixDismissEvent} helix-dismiss - A tag's remove button was pressed, or Delete or Backspace on the focused tag. Bubbles from that tag, which is its `target`; remove the tag in response. Cancelable.
+ *
+ * @csspart empty - Holds the `empty` slot while the group has no tags, rendered only then. Takes focus when the last tag is removed.
  */
 export declare class HelixHeadlessTagGroup extends HelixElement {
     /**
@@ -93,9 +104,25 @@ export declare class HelixHeadlessTagGroup extends HelixElement {
     protected press(tag: HelixHeadlessTag): void;
     private readonly handleKeydown;
     private readonly handleClick;
+    /**
+     * What happens once a tag has asked to be removed and the page has had its
+     * turn: a selected tag that left takes its value out of `value`, and focus
+     * that the last tag took with it comes to the group's `empty` part.
+     *
+     * Asked after the event and again a frame later, as `MixinDismissible`
+     * asks, because a framework removes the tag on its next render, after the
+     * handler. A canceled dismissal changes nothing.
+     */
+    private readonly handleDismiss;
+    private readonly handleSlotchange;
     private readonly handleFocusin;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    /**
+     * Whether the group is known to hold no tags, which a server and a
+     * hydrating render cannot know: there it holds whatever it was given.
+     */
+    private get empty();
     protected willUpdate(changed: PropertyValues<this>): void;
     protected updated(changed: PropertyValues<this>): void;
     protected render(): TemplateResult;

package/dist/tag/group/tag-group.js

@@ -4,11 +4,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { commaList, customElement, HelixBeforeChangeEvent, HelixElement, hostAria, KeyboardNavigationController, requestChange, rovingStop, slottedWords, whenHydrated, } from '@fusion.dev/helix-core';
-import { html } from 'lit';
+import { commaList, customElement, deepActiveElement, deepContains, HelixBeforeChangeEvent, HelixElement, hostAria, KeyboardNavigationController, pressedValue, prunedValue, requestChange, rovingStop, slottedWords, typeaheadBy, whenHydrated, } from '@fusion.dev/helix-core';
+import { html, nothing } from 'lit';
 import { property } from 'lit/decorators.js';
 import { HelixHeadlessTag } from '../root/tag-root.js';
-import { pressedValue } from '../selection.js';
 let HelixHeadlessTagGroup = class HelixHeadlessTagGroup extends HelixElement {
     constructor() {
         super(...arguments);
@@ -18,7 +17,7 @@ let HelixHeadlessTagGroup = class HelixHeadlessTagGroup extends HelixElement {
             items: () => this.reachable.map((tag) => this.navigable(tag)),
             origin: 'focus',
             selects: () => false,
-            typeahead: (item) => item.words,
+            typeahead: typeaheadBy((item) => item.words),
             wrap: false,
         });
         this.handleKeydown = (event) => {
@@ -53,6 +52,37 @@ let HelixHeadlessTagGroup = class HelixHeadlessTagGroup extends HelixElement {
                 this.press(tag);
             }
         };
+        this.handleDismiss = (event) => {
+            const tag = this.tagOf(event);
+            if (!tag) {
+                return;
+            }
+            const had = deepContains(this, deepActiveElement());
+            const settle = async () => {
+                if (event.defaultPrevented || tag.isConnected) {
+                    return;
+                }
+                const left = this.tags.map((one) => this.valueFor(one));
+                const pruned = prunedValue(this.value, this.valueFor(tag), left);
+                if (pruned !== this.value) {
+                    this.value = pruned;
+                    this.dispatchEvent(new Event('change', { bubbles: true, composed: true }));
+                }
+                const active = document.activeElement;
+                if (!had || this.tags.length > 0 || (active !== null && active !== document.body)) {
+                    return;
+                }
+                this.requestUpdate();
+                await this.updateComplete;
+                this.renderRoot.querySelector('[part~="empty"]')?.focus();
+            };
+            queueMicrotask(() => void settle());
+            requestAnimationFrame(() => void settle());
+        };
+        this.handleSlotchange = () => {
+            this.sync();
+            this.requestUpdate();
+        };
         this.handleFocusin = (event) => {
             const tag = this.tagOf(event);
             if (tag && tag !== this.last) {
@@ -122,24 +152,33 @@ let HelixHeadlessTagGroup = class HelixHeadlessTagGroup extends HelixElement {
         this.addEventListener('keydown', this.handleKeydown);
         this.addEventListener('click', this.handleClick);
         this.addEventListener('focusin', this.handleFocusin);
+        this.addEventListener('helix-dismiss', this.handleDismiss);
     }
     disconnectedCallback() {
         super.disconnectedCallback();
         this.removeEventListener('keydown', this.handleKeydown);
         this.removeEventListener('click', this.handleClick);
         this.removeEventListener('focusin', this.handleFocusin);
+        this.removeEventListener('helix-dismiss', this.handleDismiss);
+    }
+    get empty() {
+        return this.childrenKnown && this.tags.length === 0;
     }
     willUpdate(changed) {
         super.willUpdate(changed);
-        hostAria(this.internals, { label: this.label, role: 'grid' });
-        this.internals.ariaMultiSelectable = this.selectionMode === 'multiple' ? 'true' : null;
+        const empty = this.empty;
+        hostAria(this.internals, { label: this.label, role: empty ? 'group' : 'grid' });
+        this.internals.ariaMultiSelectable = this.selectionMode === 'multiple' && !empty ? 'true' : null;
     }
     updated(changed) {
         super.updated(changed);
         this.sync();
     }
     render() {
-        return html `<slot @slotchange=${() => this.sync()}></slot>`;
+        const empty = this.empty
+            ? html `<div part="empty" tabindex="-1"><slot name="empty"></slot></div>`
+            : nothing;
+        return html `<slot @slotchange=${this.handleSlotchange}></slot>${empty}`;
     }
 };
 __decorate([

package/dist/tag/root/tag-root.js

@@ -36,7 +36,10 @@ let HelixHeadlessTag = class HelixHeadlessTag extends MixinDismissible(HelixElem
     }
     willUpdate(changed) {
         super.willUpdate(changed);
-        hostAria(this.internals, { role: this.grouped ? 'row' : '' });
+        hostAria(this.internals, {
+            label: this.grouped ? this.words : '',
+            role: this.grouped ? 'row' : '',
+        });
         this.internals.ariaSelected = this.selected === undefined ? null : String(this.selected);
         this.internals.ariaDisabled = this.disabled ? 'true' : null;
         this.toggleState('selected', this.selected === true);
@@ -58,7 +61,11 @@ let HelixHeadlessTag = class HelixHeadlessTag extends MixinDismissible(HelixElem
     render() {
         const content = html `<slot name="start" part="start"></slot>${this.renderLabel()}${this.dismissible ? this.renderDismiss() : nothing}`;
         return this.grouped
-            ? html `<span part="cell" role="gridcell" tabindex=${this.focusable ? '0' : '-1'}
+            ? html `<span
+          aria-label=${this.words || nothing}
+          part="cell"
+          role="gridcell"
+          tabindex=${this.focusable ? '0' : '-1'}
           >${content}</span
         >`
             : content;