@fusion.dev/helix-headless 0.0.0-dev → 0.0.2

package/dist/toolbar/root/toolbar-root.js

@@ -28,10 +28,9 @@ const CARETLESS = new Set(['button', 'checkbox', 'color', 'file', 'image', 'rese
  * Whether the press was already the business of whatever it landed on.
  *
  * A toolbar holds anything, and some of what it holds uses the arrow keys for
- * itself. The handler below found the control the press came from and moved the
- * toolbar regardless, so an input in a toolbar could not be edited: pressing
- * ArrowRight to move the caret moved the focus to the next control instead, and
- * `preventDefault` meant the caret never moved at all.
+ * itself. Moving the toolbar regardless makes an input in a toolbar
+ * uneditable: ArrowRight moves focus to the next control, and `preventDefault`
+ * means the caret never moves at all.
  *
  * `composedPath()[0]` rather than `event.target`, which is retargeted to the
  * control's host at the shadow boundary and cannot tell a text field inside a
@@ -95,10 +94,9 @@ let HelixHeadlessToolbar = class HelixHeadlessToolbar extends HelixElement {
          * Gives the tab stop back to a control that still exists.
          *
          * `controls` excludes anything disabled or hidden, so disabling the control
-         * holding the stop dropped it out of the list while every other control was
-         * already at `-1`. The toolbar then had no tab stop at all and the keyboard
-         * could not reach it again, from a change as ordinary as a Save button
-         * disabling itself once the form is clean.
+         * holding the stop drops it out of the list while every other control is
+         * already at `-1`, leaving a toolbar the keyboard cannot reach at all. A Save
+         * button disabling itself once the form is clean is enough to do it.
          *
          * `foreign` stays false, the same as the first claim: a control this package
          * has never heard of that was never given `tabindex="-1"` is still in the
@@ -153,12 +151,10 @@ let HelixHeadlessToolbar = class HelixHeadlessToolbar extends HelixElement {
      * toolbar holds anything, including elements this package has never heard of.
      * Client only, there being no tree to walk on the server.
      *
-     * **It does not ask a child whether it is focusable, and the description said
-     * it did.** That would mean reading a `focusable` property off each one, which
-     * `focus` below does when moving the stop and this does not when choosing the
-     * set. The two are separable and only one of them was ever written: an element
-     * that is neither disabled nor hidden and still cannot take focus is counted
-     * here and skipped there.
+     * **It does not ask a child whether it is focusable.** Reading a `focusable`
+     * property is what `setTabStop` does when moving the stop, not what this does
+     * when choosing the set, so an element that is neither disabled nor hidden and
+     * still cannot take focus is counted here and skipped there.
      */
     get controls() {
         return [...this.children].filter((child) => {

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

@@ -85,6 +85,22 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
      * of using fallback content rather than rendering whichever is present.
      */
     content: string;
+    /**
+     * How long the pointer must rest before the bubble appears, in milliseconds.
+     *
+     * Without one, sweeping across a row of controls flashes a tooltip for each
+     * of them, which is noise rather than help. Focus opens with no delay: a
+     * keyboard reader arriving on a control has already committed to it.
+     */
+    delay: number;
+    /**
+     * How long the bubble stays after the pointer leaves, in milliseconds.
+     */
+    delayOut: number;
+    /**
+     * Whether the tooltip never shows.
+     */
+    disabled: boolean;
     /**
      * The id of the element this describes, in this tooltip's own tree.
      *
@@ -105,12 +121,6 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
      * why this does not reflect and nothing styles on it.
      */
     for: string;
-    /**
-     * Preferred side.
-     *
-     * It moves if that side does not fit.
-     */
-    placement: Placement;
     /**
      * Space between the trigger and the point of the bubble, in pixels.
      *
@@ -123,34 +133,15 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
      * it changes the visible gap rather than a number the arrow then eats into.
      */
     offset: number;
-    /**
-     * The id of a box to keep the bubble inside, instead of the viewport.
-     *
-     * Resolved the way `for` is, so an id in the same tree, which is what lets a
-     * component name a box in its own shadow root. A chart does: its bubble is
-     * centered on a reading, and the first and last readings sit at the ends of
-     * the plot, so half the box hangs past the drawing and, measured on a chart
-     * in a 320px card, three pixels past the card itself.
-     *
-     * Clamping is on the cross axis only, which is what makes this safe to point
-     * at a box the bubble genuinely does not fit inside. See `within` on
-     * `FloatingController` for what happens if it is applied to the rest.
-     */
-    within: string;
-    /**
-     * Whether the tooltip never shows.
-     */
-    disabled: boolean;
     /**
      * Whether the bubble survives the trigger being used.
      *
      * **Activation takes a tooltip down, because a hint about what a control will
      * do is spent once the control has done it.** That is right for a gear that
      * opens a drawer and wrong for a control whose tooltip *becomes* the answer:
-     * `CopyButton` swaps its content from Copy to Copied on the same click, so the
-     * bubble was being hidden at the exact moment it had something to say. What a
-     * reader saw was a flash, and the confirmation the component had carefully
-     * written was never on screen long enough to read.
+     * `CopyButton` swaps its content from Copy to Copied on the same click, so
+     * the bubble would be hidden at the exact moment it has something to say and
+     * the confirmation would never be on screen long enough to read.
      *
      * So this is not "keep it open", it is "the hint is not spent": set it where
      * the words change to describe what just happened, and leave it alone
@@ -160,26 +151,33 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
      */
     persist: boolean;
     /**
-     * How long the pointer must rest before the bubble appears, in milliseconds.
+     * Preferred side.
      *
-     * Without one, sweeping across a row of controls flashes a tooltip for each
-     * of them, which is noise rather than help. Focus opens with no delay: a
-     * keyboard reader arriving on a control has already committed to it.
+     * It moves if that side does not fit.
      */
-    delay: number;
+    placement: Placement;
     /**
-     * How long the bubble stays after the pointer leaves, in milliseconds.
+     * The id of a box to keep the bubble inside, instead of the viewport.
+     *
+     * Resolved the way `for` is, so an id in the same tree, which is what lets a
+     * component name a box in its own shadow root. A chart does: its bubble is
+     * centered on a reading, and the first and last readings sit at the ends of
+     * the plot, so half the box hangs past the drawing and, measured on a chart
+     * in a 320px card, three pixels past the card itself.
+     *
+     * Clamping is on the cross axis only, which is what makes this safe to point
+     * at a box the bubble genuinely does not fit inside. See `within` on
+     * `FloatingController` for what happens if it is applied to the rest.
      */
-    delayOut: number;
+    within: string;
     private timer;
     /**
      * What is currently keeping the bubble up.
      *
-     * The pointer and focus are two holders and they shared one timer with
-     * nothing counting them, so whichever left last won: moving the pointer off a
-     * control that still had keyboard focus scheduled a hide and took the bubble
-     * away from under the reader. The same fault the toast timer had, and the
-     * same answer.
+     * The pointer and focus are two holders, so a single timer with nothing
+     * counting them hides on whichever leaves last: moving the pointer off a
+     * control that still has keyboard focus would take the bubble away from under
+     * the reader. Same shape as the toast timer, and the same answer.
      */
     private readonly holds;
     /**
@@ -272,15 +270,11 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
      * Focus opens the bubble, but only the kind of focus a reader chose.
      *
      * **A mouse press focuses the button it pressed**, so an unconditional focus
-     * hold meant that after any click the bubble was held up by a reader who was
-     * not asking for it: moving the pointer away released the pointer hold, found
-     * a focus hold still set, and left the tooltip on screen until something else
-     * blurred the control.
-     *
-     * It never showed until `persist` arrived, because activation used to clear
-     * every hold and hide, so the click path threw the stale hold away before
-     * anyone could see it. A tooltip that survives its own activation is the first
-     * one to hold that focus long enough to matter.
+     * hold leaves the bubble up after any click for a reader who was not asking
+     * for it: moving the pointer away releases the pointer hold, finds a focus
+     * hold still set, and leaves the tooltip on screen until something else blurs
+     * the control. `persist` is what makes that reachable, activation otherwise
+     * clearing every hold before anyone can see it.
      *
      * `:focus-visible` is the platform's own answer to "did they mean it", and a
      * button does not match it on a mouse press. Keyboard focus still opens with no
@@ -293,14 +287,14 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
     /** Hides only once nothing is holding the bubble up. */
     private release;
     /**
-     * Activating the trigger closes the bubble, which nothing was doing.
+     * Activating the trigger closes the bubble.
      *
      * A tooltip is a hint about what a control will do, and once the control has
-     * been used the hint is spent. Nothing else was going to take it down either:
+     * been used the hint is spent. Nothing else takes it down either:
      * `pointerleave` cannot fire while the pointer is still on the button it just
      * pressed, and `focusout` does not fire when activation leaves focus where it
-     * was. So a gear that opened a drawer left its own label floating over the
-     * drawer until the reader moved the mouse away.
+     * was. Without this, a gear that opened a drawer leaves its own label
+     * floating over the drawer until the reader moves the mouse away.
      *
      * `click` rather than `pointerdown`, because it is the one event both a mouse
      * and a keyboard produce: Enter and Space on a focused button raise it, and a
@@ -320,11 +314,10 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
     /**
      * Escape closes the bubble from wherever the reader is.
      *
-     * On the document, not on the host, which is where it was: a tooltip opened
-     * by hover has focus somewhere else entirely, so the press never reached this
-     * element and Escape worked only for the one case that needed it least. That
-     * is the case the pattern names, a reader escaping a tooltip obscuring what
-     * is under it, and it was the case that did nothing.
+     * On the document, not on the host: a tooltip opened by hover has focus
+     * somewhere else entirely, so a press never reaches this element and Escape
+     * would work for everything except the case the pattern is named for, a
+     * reader escaping a tooltip obscuring what is under it.
      *
      * Not stopped from propagating: a tooltip is not what the reader was trying
      * to escape if it sits inside something else that also closes.
@@ -365,7 +358,7 @@ export declare class HelixHeadlessTooltip extends HelixHeadlessTooltip_base {
      *
      * On first open rather than on connect, because a framework may render the
      * attribute after this element upgrades, and because a tooltip that never
-     * opens has described nothing eitherway.
+     * opens has described nothing either way.
      *
      * Either attribute counts. WebAwesome uses `aria-labelledby` over
      * `aria-describedby` on purpose, their reasoning being that some screen

package/dist/tooltip/root/tooltip-root.js

@@ -95,6 +95,22 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
          * of using fallback content rather than rendering whichever is present.
          */
         this.content = '';
+        /**
+         * How long the pointer must rest before the bubble appears, in milliseconds.
+         *
+         * Without one, sweeping across a row of controls flashes a tooltip for each
+         * of them, which is noise rather than help. Focus opens with no delay: a
+         * keyboard reader arriving on a control has already committed to it.
+         */
+        this.delay = 400;
+        /**
+         * How long the bubble stays after the pointer leaves, in milliseconds.
+         */
+        this.delayOut = 100;
+        /**
+         * Whether the tooltip never shows.
+         */
+        this.disabled = false;
         /**
          * The id of the element this describes, in this tooltip's own tree.
          *
@@ -115,12 +131,6 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
          * why this does not reflect and nothing styles on it.
          */
         this.for = '';
-        /**
-         * Preferred side.
-         *
-         * It moves if that side does not fit.
-         */
-        this.placement = 'top';
         /**
          * Space between the trigger and the point of the bubble, in pixels.
          *
@@ -133,34 +143,15 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
          * it changes the visible gap rather than a number the arrow then eats into.
          */
         this.offset = 8;
-        /**
-         * The id of a box to keep the bubble inside, instead of the viewport.
-         *
-         * Resolved the way `for` is, so an id in the same tree, which is what lets a
-         * component name a box in its own shadow root. A chart does: its bubble is
-         * centered on a reading, and the first and last readings sit at the ends of
-         * the plot, so half the box hangs past the drawing and, measured on a chart
-         * in a 320px card, three pixels past the card itself.
-         *
-         * Clamping is on the cross axis only, which is what makes this safe to point
-         * at a box the bubble genuinely does not fit inside. See `within` on
-         * `FloatingController` for what happens if it is applied to the rest.
-         */
-        this.within = '';
-        /**
-         * Whether the tooltip never shows.
-         */
-        this.disabled = false;
         /**
          * Whether the bubble survives the trigger being used.
          *
          * **Activation takes a tooltip down, because a hint about what a control will
          * do is spent once the control has done it.** That is right for a gear that
          * opens a drawer and wrong for a control whose tooltip *becomes* the answer:
-         * `CopyButton` swaps its content from Copy to Copied on the same click, so the
-         * bubble was being hidden at the exact moment it had something to say. What a
-         * reader saw was a flash, and the confirmation the component had carefully
-         * written was never on screen long enough to read.
+         * `CopyButton` swaps its content from Copy to Copied on the same click, so
+         * the bubble would be hidden at the exact moment it has something to say and
+         * the confirmation would never be on screen long enough to read.
          *
          * So this is not "keep it open", it is "the hint is not spent": set it where
          * the words change to describe what just happened, and leave it alone
@@ -170,36 +161,38 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
          */
         this.persist = false;
         /**
-         * How long the pointer must rest before the bubble appears, in milliseconds.
+         * Preferred side.
          *
-         * Without one, sweeping across a row of controls flashes a tooltip for each
-         * of them, which is noise rather than help. Focus opens with no delay: a
-         * keyboard reader arriving on a control has already committed to it.
+         * It moves if that side does not fit.
          */
-        this.delay = 400;
+        this.placement = 'top';
         /**
-         * How long the bubble stays after the pointer leaves, in milliseconds.
+         * The id of a box to keep the bubble inside, instead of the viewport.
+         *
+         * Resolved the way `for` is, so an id in the same tree, which is what lets a
+         * component name a box in its own shadow root. A chart does: its bubble is
+         * centered on a reading, and the first and last readings sit at the ends of
+         * the plot, so half the box hangs past the drawing and, measured on a chart
+         * in a 320px card, three pixels past the card itself.
+         *
+         * Clamping is on the cross axis only, which is what makes this safe to point
+         * at a box the bubble genuinely does not fit inside. See `within` on
+         * `FloatingController` for what happens if it is applied to the rest.
          */
-        this.delayOut = 100;
+        this.within = '';
         /**
          * What is currently keeping the bubble up.
          *
-         * The pointer and focus are two holders and they shared one timer with
-         * nothing counting them, so whichever left last won: moving the pointer off a
-         * control that still had keyboard focus scheduled a hide and took the bubble
-         * away from under the reader. The same fault the toast timer had, and the
-         * same answer.
+         * The pointer and focus are two holders, so a single timer with nothing
+         * counting them hides on whichever leaves last: moving the pointer off a
+         * control that still has keyboard focus would take the bubble away from under
+         * the reader. Same shape as the toast timer, and the same answer.
          */
         this.holds = new Set();
-        /* One controller rather than the pair this was: a `FloatingController` beside
-           hand-written `showPopover`/`hidePopover` calls, which is exactly the
-           composition `PopoverController` exists to own. Its own documentation named
-           the controller it was not using.
-         *
-         * The boundary is the host and not the bubble, for the reason `Popover` gives:
-         * the host is `display: contents`, so a press on the trigger is inside the
-         * host and outside the bubble, and a boundary of the bubble alone would treat
-         * the press that opened it as a press outside. */
+        /* The boundary is the host and not the bubble, for the reason `Popover` gives:
+           the host is `display: contents`, so a press on the trigger is inside the
+           host and outside the bubble, and a boundary of the bubble alone would treat
+           the press that opened it as a press outside. */
         this.bubbleLayer = new PopoverController(this, {
             anchor: () => this.trigger,
             arrow: () => this.renderRoot.querySelector('[part="arrow"]'),
@@ -254,15 +247,11 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
          * Focus opens the bubble, but only the kind of focus a reader chose.
          *
          * **A mouse press focuses the button it pressed**, so an unconditional focus
-         * hold meant that after any click the bubble was held up by a reader who was
-         * not asking for it: moving the pointer away released the pointer hold, found
-         * a focus hold still set, and left the tooltip on screen until something else
-         * blurred the control.
-         *
-         * It never showed until `persist` arrived, because activation used to clear
-         * every hold and hide, so the click path threw the stale hold away before
-         * anyone could see it. A tooltip that survives its own activation is the first
-         * one to hold that focus long enough to matter.
+         * hold leaves the bubble up after any click for a reader who was not asking
+         * for it: moving the pointer away releases the pointer hold, finds a focus
+         * hold still set, and leaves the tooltip on screen until something else blurs
+         * the control. `persist` is what makes that reachable, activation otherwise
+         * clearing every hold before anyone can see it.
          *
          * `:focus-visible` is the platform's own answer to "did they mean it", and a
          * button does not match it on a mouse press. Keyboard focus still opens with no
@@ -283,14 +272,14 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
             this.release();
         };
         /**
-         * Activating the trigger closes the bubble, which nothing was doing.
+         * Activating the trigger closes the bubble.
          *
          * A tooltip is a hint about what a control will do, and once the control has
-         * been used the hint is spent. Nothing else was going to take it down either:
+         * been used the hint is spent. Nothing else takes it down either:
          * `pointerleave` cannot fire while the pointer is still on the button it just
          * pressed, and `focusout` does not fire when activation leaves focus where it
-         * was. So a gear that opened a drawer left its own label floating over the
-         * drawer until the reader moved the mouse away.
+         * was. Without this, a gear that opened a drawer leaves its own label
+         * floating over the drawer until the reader moves the mouse away.
          *
          * `click` rather than `pointerdown`, because it is the one event both a mouse
          * and a keyboard produce: Enter and Space on a focused button raise it, and a
@@ -316,11 +305,10 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
         /**
          * Escape closes the bubble from wherever the reader is.
          *
-         * On the document, not on the host, which is where it was: a tooltip opened
-         * by hover has focus somewhere else entirely, so the press never reached this
-         * element and Escape worked only for the one case that needed it least. That
-         * is the case the pattern names, a reader escaping a tooltip obscuring what
-         * is under it, and it was the case that did nothing.
+         * On the document, not on the host: a tooltip opened by hover has focus
+         * somewhere else entirely, so a press never reaches this element and Escape
+         * would work for everything except the case the pattern is named for, a
+         * reader escaping a tooltip obscuring what is under it.
          *
          * Not stopped from propagating: a tooltip is not what the reader was trying
          * to escape if it sits inside something else that also closes.
@@ -350,11 +338,9 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
         if (named) {
             return named;
         }
-        /* Through the util, which was written from a measurement of this component
-           and then not used by it. Its extra is the descent: the first assigned
-           element may itself draw nothing, and an icon button wrapped in a
-           `display: contents` span was the case that took the bubble to the corner
-           of the window. */
+        /* Through the util, whose extra is the descent: the first assigned element
+           may itself draw nothing, and an icon button wrapped in a
+           `display: contents` span takes the bubble to the corner of the window. */
         return anchorElement(this.renderRoot.querySelector('slot:not([name])'), this);
     }
     /**
@@ -430,12 +416,11 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
             }
             /* A wrapper is empty when it holds nothing; anything else draws.
              *
-             * The test was children-or-text for every element, which reads as careful
-             * and refused the exact case this getter's own paragraph calls the whole
-             * point of slotting. `<helix-icon slot="content">` has no children and no
-             * text, so `hasContent` was false, `show()` returned early, and a tooltip
-             * whose bubble is an icon could not be opened at all. Measured in a
-             * browser: `open` stayed false through a direct `show()`.
+             * Not children-or-text for every element, which reads as careful and
+             * refuses the exact case this getter's own paragraph calls the whole
+             * point of slotting: `<helix-icon slot="content">` has no children and no
+             * text, so `hasContent` would be false, `show()` would return early, and
+             * a tooltip whose bubble is an icon could not be opened at all.
              *
              * The spec beside this one is the other half, and it is why the answer is
              * not simply "an element is content": `<span slot="content">   </span>`
@@ -547,7 +532,7 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
      *
      * On first open rather than on connect, because a framework may render the
      * attribute after this element upgrades, and because a tooltip that never
-     * opens has described nothing eitherway.
+     * opens has described nothing either way.
      *
      * Either attribute counts. WebAwesome uses `aria-labelledby` over
      * `aria-describedby` on purpose, their reasoning being that some screen
@@ -556,10 +541,30 @@ let HelixHeadlessTooltip = class HelixHeadlessTooltip extends MixinControllerOpe
      * this should not be the thing to settle it.
      */
     auditDescription() {
-        if (this.audited || this.for === '' || !this.hasContent) {
+        if (this.audited || !this.hasContent) {
             return;
         }
         this.audited = true;
+        /* **The unlinked form is the one that describes nothing, so it is the one
+           warned about.** This returned on `for === ''`, which made the guard the
+           exact inverse of the risk: the wrapping form is never linked, so it was
+           the single form that could never be reported.
+    
+           Measured in Chrome's accessibility tree,
+           `<helix-tooltip content="..."><helix-button>Save</helix-button></helix-tooltip>`
+           exposes `button name="Save" desc=""`. All three routes to fixing it are
+           closed: an `aria-describedby` IDREF resolves only within one tree,
+           `ariaDescribedByElements` is valid outward and this points inward, and
+           `aria-description` is the hydration mismatch 322 closed the library
+           against. So the wrapping form is no longer the documented API, and this
+           says so once, where somebody using it will see it. */
+        if (this.for === '') {
+            console.warn(`<${this.localName}> is wrapping its trigger rather than naming one, so its text ` +
+                "reaches no screen reader: a description in this element's shadow root cannot be " +
+                'referenced from a trigger in the light DOM. Give this tooltip an `id`, set `for` to ' +
+                'the trigger\'s id, and add `aria-describedby="<that id>"` to the trigger.');
+            return;
+        }
         const trigger = this.named;
         if (!trigger) {
             console.warn(`<${this.localName} for="${this.for}"> found no element with that id in its own tree, ` +
@@ -678,29 +683,29 @@ __decorate([
     property()
 ], HelixHeadlessTooltip.prototype, "content", void 0);
 __decorate([
-    property()
-], HelixHeadlessTooltip.prototype, "for", void 0);
+    property({ attribute: 'delay', type: Number })
+], HelixHeadlessTooltip.prototype, "delay", void 0);
 __decorate([
-    property()
-], HelixHeadlessTooltip.prototype, "placement", void 0);
+    property({ attribute: 'delay-out', type: Number })
+], HelixHeadlessTooltip.prototype, "delayOut", void 0);
 __decorate([
-    property({ type: Number })
-], HelixHeadlessTooltip.prototype, "offset", void 0);
+    property({ reflect: true, type: Boolean })
+], HelixHeadlessTooltip.prototype, "disabled", void 0);
 __decorate([
     property()
-], HelixHeadlessTooltip.prototype, "within", void 0);
+], HelixHeadlessTooltip.prototype, "for", void 0);
 __decorate([
-    property({ reflect: true, type: Boolean })
-], HelixHeadlessTooltip.prototype, "disabled", void 0);
+    property({ type: Number })
+], HelixHeadlessTooltip.prototype, "offset", void 0);
 __decorate([
     property({ reflect: true, type: Boolean })
 ], HelixHeadlessTooltip.prototype, "persist", void 0);
 __decorate([
-    property({ attribute: 'delay', type: Number })
-], HelixHeadlessTooltip.prototype, "delay", void 0);
+    property()
+], HelixHeadlessTooltip.prototype, "placement", void 0);
 __decorate([
-    property({ attribute: 'delay-out', type: Number })
-], HelixHeadlessTooltip.prototype, "delayOut", void 0);
+    property()
+], HelixHeadlessTooltip.prototype, "within", void 0);
 HelixHeadlessTooltip = __decorate([
     customElement('helix-headless-tooltip')
 ], HelixHeadlessTooltip);

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

@@ -60,24 +60,20 @@ import type { HelixHeadlessTourStop } from '../stop/tour-stop.js';
  */
 export declare class HelixHeadlessTour extends HelixElement {
     /**
-     * Whether the tour is running.
+     * Label for the control that goes back, handed to every stop.
      */
-    open: boolean;
+    backLabel: string;
     /**
      * Which stop the reader is on.
      *
-     * **It announced after it moved for two days, which made refusing it
-     * impossible.** `index` was a plain property the tour wrote to directly:
-     * `move` assigned it and *then* announced, so `preventDefault` on the change
-     * arrived after the move it was refusing. It goes through `requestChange`
-     * now, which announces first and applies only if nobody refused, and refusing
-     * is how a consumer takes the decision. See 294.
+     * **Moved through `requestChange`, never by assignment from `move`.** That
+     * announces first and applies only if nobody refused, and refusing is how a
+     * consumer takes the decision; writing the property and then announcing puts
+     * `preventDefault` after the move it is refusing.
      *
      * The shape is `Carousel`'s, which is the nearest thing in the library: a
      * `default-index` for markup that only seeds and a held state that is
      * `undefined` until somebody sets one.
-     *
-     *
      */
     get index(): number;
     set index(next: number);
@@ -88,29 +84,29 @@ export declare class HelixHeadlessTour extends HelixElement {
     /** The stop being shown, whoever set it, and `undefined` until somebody has. */
     private indexState;
     /**
-     * Accessible name for the run, such as "Getting started".
-     */
-    label: string;
-    /**
-     * Space left around the target when it is lit, in pixels.
+     * Label for the control that goes on from the last stop.
      */
-    spotlightPadding: number;
+    doneLabel: string;
     /**
-     * Label for the control that goes back, handed to every stop.
+     * Accessible name for the run, such as "Getting started".
      */
-    backLabel: string;
+    label: string;
     /**
      * Label for the control that goes on.
      */
     nextLabel: string;
     /**
-     * Label for the control that goes on from the last stop.
+     * Whether the tour is running.
      */
-    doneLabel: string;
+    open: boolean;
     /**
      * Label for the control that leaves the tour.
      */
     skipLabel: string;
+    /**
+     * Space left around the target when it is lit, in pixels.
+     */
+    spotlightPadding: number;
     private assigned;
     /**
      * Where the light falls, read from the current target.
@@ -127,9 +123,9 @@ export declare class HelixHeadlessTour extends HelixElement {
     /**
      * Leaves the run early, which is a close rather than a completion.
      *
-     * Announced before it is applied, and cancelable because of it. Both closes
-     * wrote `open` first and dispatched after, so a consumer calling
-     * `preventDefault` was refusing something that had already happened.
+     * Announced before it is applied, and cancelable because of it: writing
+     * `open` first and dispatching after leaves a consumer calling
+     * `preventDefault` refusing something that has already happened.
      */
     skip(): void;
     private finish;