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

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

@@ -9,10 +9,9 @@ declare const HelixHeadlessCombobox_base: (new (...args: any[]) => import("@fusi
  * @description
  * **The list is `helix-listbox`, and the filtering is its own.** It already
  * owns narrowing, the empty state, the highlight, `aria-activedescendant` and
- * scrolling an option into view, and every one of those is a decision with a
- * long note attached. Rewriting them here would be a second copy to keep in
- * step; what is left for this element is the field, the panel and the traffic
- * between them.
+ * scrolling an option into view. Rewriting them here would be a second copy to
+ * keep in step; what is left for this element is the field, the panel and the
+ * traffic between them.
  *
  * **The text and the value are two things.** What a reader types is a filter,
  * not an answer: it narrows the list and is thrown away. The value is whichever
@@ -24,7 +23,7 @@ declare const HelixHeadlessCombobox_base: (new (...args: any[]) => import("@fusi
  * That is also why the field is emptied of its filter on close rather than left
  * holding it: a control reopened still narrowed by the last visit's search is a
  * control whose second use starts from the first one's leftovers. Select
- * records the same, having been fixed for it.
+ * records the same.
  *
  * **Focus stays in the field, which is the whole of what a combobox is.** The
  * arrows move the list without leaving the text, which is why the listbox has a
@@ -111,7 +110,6 @@ declare const HelixHeadlessCombobox_base: (new (...args: any[]) => import("@fusi
  * @csspart listbox-items - The list itself.
  * @csspart listbox-label - The question, over the list.
  * @csspart listbox-loading - Shown while the options are still on their way.
- * from the listbox.
  * @csspart listbox-search - The region holding the field that narrows the list.
  * @csspart listbox-search-field - The field itself.
  * @csspart rest - The count of choices held beyond `max-tags`.
@@ -133,21 +131,6 @@ export declare class HelixHeadlessCombobox extends HelixHeadlessCombobox_base {
      * keystrokes as the listbox. A consumer who wants autofill can still ask.
      */
     autocomplete: string;
-    /**
-     * Text shown while nothing has been chosen.
-     */
-    placeholder: string;
-    /**
-     * Whether more than one option can be chosen.
-     *
-     * The list already does the work: `value` comes apart on commas, a press
-     * toggles rather than replaces, and the arrows move without choosing. What
-     * this adds is the tags, and keeping the panel open between picks.
-     *
-     * A comma is therefore not available inside an option's value, which is the
-     * listbox's contract and not this element's to change.
-     */
-    multiple: boolean;
     /**
      * Whether the reader may answer with something the list does not hold.
      *
@@ -157,23 +140,29 @@ export declare class HelixHeadlessCombobox extends HelixHeadlessCombobox_base {
      * halfway through.
      */
     creatable: boolean;
-    /**
-     * Whether the field finishes the word as it is typed.
-     *
-     * `suggest` rather than `autocomplete`, which is a real HTML attribute this
-     * element already sets on the input it renders, and two things of one name
-     * meaning different things on the same control is a question a consumer
-     * should not have to ask.
-     */
-    suggest: boolean;
     /**
      * What the create row says, before the words it would add.
      */
     createLabel: string;
     /**
-     * What a tag's remove control is called, since the mark has no name.
+     * Words shown where the filter has hidden everything.
      */
-    removeLabel: string;
+    emptyText: string;
+    /**
+     * Accessible name for the list, which has no visible one of its own.
+     */
+    listLabel: string;
+    /**
+     * Whether the options are still on their way.
+     *
+     * Passed straight to the list, which is where the rows are and so where the
+     * message belongs.
+     */
+    loading: boolean;
+    /**
+     * What the list says while they are on their way.
+     */
+    loadingText: string;
     /**
      * How many tags to draw before the rest become a count. `multiple` only.
      *
@@ -190,24 +179,33 @@ export declare class HelixHeadlessCombobox extends HelixHeadlessCombobox_base {
      */
     maxTags: number;
     /**
-     * Accessible name for the list, which has no visible one of its own.
+     * Whether more than one option can be chosen.
+     *
+     * The list already does the work: `value` comes apart on commas, a press
+     * toggles rather than replaces, and the arrows move without choosing. What
+     * this adds is the tags, and keeping the panel open between picks.
+     *
+     * A comma is therefore not available inside an option's value, which is the
+     * listbox's contract and not this element's to change.
      */
-    listLabel: string;
+    multiple: boolean;
     /**
-     * Whether the options are still on their way.
-     *
-     * Passed straight to the list, which is where the rows are and so where the
-     * message belongs.
+     * Text shown while nothing has been chosen.
      */
-    loading: boolean;
+    placeholder: string;
     /**
-     * What the list says while they are on their way.
+     * What a tag's remove control is called, since the mark has no name.
      */
-    loadingText: string;
+    removeLabel: string;
     /**
-     * Words shown where the filter has hidden everything.
+     * Whether the field finishes the word as it is typed.
+     *
+     * `suggest` rather than `autocomplete`, which is a real HTML attribute this
+     * element already sets on the input it renders, and two things of one name
+     * meaning different things on the same control is a question a consumer
+     * should not have to ask.
      */
-    emptyText: string;
+    suggest: boolean;
     /**
      * What the reader has typed, which narrows the list and is not the value.
      *
@@ -323,11 +321,10 @@ export declare class HelixHeadlessCombobox extends HelixHeadlessCombobox_base {
     /**
      * Anywhere in the field opens the list, and puts the caret where typing goes.
      *
-     * On the field rather than on the `<input>`, which is where it was. The caret
-     * is a sibling of the input and so is the tag strip, so pressing the one part
-     * of the control that visibly says "this opens" did nothing at all, and a
-     * reader who wanted the list had to find the text box. Anything drawn inside
-     * the field is the field.
+     * On the field rather than on the `<input>`. The caret is a sibling of the
+     * input and so is the tag strip, so a handler on the input alone leaves the
+     * one part of the control that visibly says "this opens" doing nothing.
+     * Anything drawn inside the field is the field.
      *
      * A tag is the exception, because a tag is its own control: its dismiss
      * removes a choice, and opening the list on the way past would leave the
@@ -354,23 +351,21 @@ export declare class HelixHeadlessCombobox extends HelixHeadlessCombobox_base {
     /**
      * The list the field filters, behind a seam the styled tier can move.
      *
-     * A method rather than a fragment inline, so a tier above can render its own,
-     * wrap this one, pass it a property the base does not know about, or leave it
-     * out, without reimplementing the whole template to do any of them. The tag is
+     * A method rather than a fragment inline, so a tier above can replace, wrap
+     * or omit it without reimplementing the whole template. The tag is
      * interpolated rather than written, so `tier` resolves it: this renders the
-     * headless element, and a styled subclass that sets `tier` renders the styled one
-     * from the same template.
+     * headless element, and a styled subclass that sets `tier` renders the styled
+     * one from the same template.
      */
     protected renderListbox(): TemplateResult;
     /**
      * One chosen option, as a tag, behind a seam the styled tier can move.
      *
-     * A method rather than a fragment inline, so a tier above can render its own,
-     * wrap this one, pass it a property the base does not know about, or leave it
-     * out, without reimplementing the whole template to do any of them. The tag is
+     * A method rather than a fragment inline, so a tier above can replace, wrap
+     * or omit it without reimplementing the whole template. The tag is
      * interpolated rather than written, so `tier` resolves it: this renders the
-     * headless element, and a styled subclass that sets `tier` renders the styled one
-     * from the same template.
+     * headless element, and a styled subclass that sets `tier` renders the styled
+     * one from the same template.
      */
     protected renderTag(option: {
         text: string;

package/dist/combobox/root/combobox-root.js

@@ -35,10 +35,9 @@ const isInsertion = (event) => !event.inputType?.startsWith('delete');
  * @description
  * **The list is `helix-listbox`, and the filtering is its own.** It already
  * owns narrowing, the empty state, the highlight, `aria-activedescendant` and
- * scrolling an option into view, and every one of those is a decision with a
- * long note attached. Rewriting them here would be a second copy to keep in
- * step; what is left for this element is the field, the panel and the traffic
- * between them.
+ * scrolling an option into view. Rewriting them here would be a second copy to
+ * keep in step; what is left for this element is the field, the panel and the
+ * traffic between them.
  *
  * **The text and the value are two things.** What a reader types is a filter,
  * not an answer: it narrows the list and is thrown away. The value is whichever
@@ -50,7 +49,7 @@ const isInsertion = (event) => !event.inputType?.startsWith('delete');
  * That is also why the field is emptied of its filter on close rather than left
  * holding it: a control reopened still narrowed by the last visit's search is a
  * control whose second use starts from the first one's leftovers. Select
- * records the same, having been fixed for it.
+ * records the same.
  *
  * **Focus stays in the field, which is the whole of what a combobox is.** The
  * arrows move the list without leaving the text, which is why the listbox has a
@@ -137,7 +136,6 @@ const isInsertion = (event) => !event.inputType?.startsWith('delete');
  * @csspart listbox-items - The list itself.
  * @csspart listbox-label - The question, over the list.
  * @csspart listbox-loading - Shown while the options are still on their way.
- * from the listbox.
  * @csspart listbox-search - The region holding the field that narrows the list.
  * @csspart listbox-search-field - The field itself.
  * @csspart rest - The count of choices held beyond `max-tags`.
@@ -168,21 +166,6 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
          * keystrokes as the listbox. A consumer who wants autofill can still ask.
          */
         this.autocomplete = 'off';
-        /**
-         * Text shown while nothing has been chosen.
-         */
-        this.placeholder = '';
-        /**
-         * Whether more than one option can be chosen.
-         *
-         * The list already does the work: `value` comes apart on commas, a press
-         * toggles rather than replaces, and the arrows move without choosing. What
-         * this adds is the tags, and keeping the panel open between picks.
-         *
-         * A comma is therefore not available inside an option's value, which is the
-         * listbox's contract and not this element's to change.
-         */
-        this.multiple = false;
         /**
          * Whether the reader may answer with something the list does not hold.
          *
@@ -192,23 +175,29 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
          * halfway through.
          */
         this.creatable = false;
-        /**
-         * Whether the field finishes the word as it is typed.
-         *
-         * `suggest` rather than `autocomplete`, which is a real HTML attribute this
-         * element already sets on the input it renders, and two things of one name
-         * meaning different things on the same control is a question a consumer
-         * should not have to ask.
-         */
-        this.suggest = false;
         /**
          * What the create row says, before the words it would add.
          */
         this.createLabel = 'Add';
         /**
-         * What a tag's remove control is called, since the mark has no name.
+         * Words shown where the filter has hidden everything.
          */
-        this.removeLabel = 'Remove';
+        this.emptyText = 'No matches';
+        /**
+         * Accessible name for the list, which has no visible one of its own.
+         */
+        this.listLabel = 'Options';
+        /**
+         * Whether the options are still on their way.
+         *
+         * Passed straight to the list, which is where the rows are and so where the
+         * message belongs.
+         */
+        this.loading = false;
+        /**
+         * What the list says while they are on their way.
+         */
+        this.loadingText = 'Loading';
         /**
          * How many tags to draw before the rest become a count. `multiple` only.
          *
@@ -225,24 +214,33 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
          */
         this.maxTags = 0;
         /**
-         * Accessible name for the list, which has no visible one of its own.
+         * Whether more than one option can be chosen.
+         *
+         * The list already does the work: `value` comes apart on commas, a press
+         * toggles rather than replaces, and the arrows move without choosing. What
+         * this adds is the tags, and keeping the panel open between picks.
+         *
+         * A comma is therefore not available inside an option's value, which is the
+         * listbox's contract and not this element's to change.
          */
-        this.listLabel = 'Options';
+        this.multiple = false;
         /**
-         * Whether the options are still on their way.
-         *
-         * Passed straight to the list, which is where the rows are and so where the
-         * message belongs.
+         * Text shown while nothing has been chosen.
          */
-        this.loading = false;
+        this.placeholder = '';
         /**
-         * What the list says while they are on their way.
+         * What a tag's remove control is called, since the mark has no name.
          */
-        this.loadingText = 'Loading';
+        this.removeLabel = 'Remove';
         /**
-         * Words shown where the filter has hidden everything.
+         * Whether the field finishes the word as it is typed.
+         *
+         * `suggest` rather than `autocomplete`, which is a real HTML attribute this
+         * element already sets on the input it renders, and two things of one name
+         * meaning different things on the same control is a question a consumer
+         * should not have to ask.
          */
-        this.emptyText = 'No matches';
+        this.suggest = false;
         /**
          * What the reader has typed, which narrows the list and is not the value.
          *
@@ -262,10 +260,9 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
         this.suggestion = '';
         this.panel = new PopoverController(this, {
             anchor: () => this.renderRoot?.querySelector('[part="field"]'),
-            /* The surface *and* the field, for the reason four components here were
-               fixed for: scoped to the surface alone, a press on the field counts as
-               outside, so `pointerdown` closes the panel and the field's own handler
-               reopens it on the `click` that follows. */
+            /* The surface *and* the field. Scoped to the surface alone, a press on the
+               field counts as outside, so `pointerdown` closes the panel and the
+               field's own handler reopens it on the `click` that follows. */
             boundary: () => [
                 this.renderRoot?.querySelector('[part="surface"]'),
                 this.renderRoot?.querySelector('[part="field"]'),
@@ -365,7 +362,7 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
                it carries what is being *proposed*, dispatched before it is applied,
                which is what makes it refusable. The listbox never applies it anyway,
                since this element passes `.value` down and that is a consumer declaring
-               ownership. Select was fixed for exactly this. */
+               ownership. */
             const { value } = event.detail;
             /* And nothing happens on a refusal. Refusing a change should leave the
                control where it was, not clear the filter and shut the panel as though
@@ -384,11 +381,10 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
         /**
          * Anywhere in the field opens the list, and puts the caret where typing goes.
          *
-         * On the field rather than on the `<input>`, which is where it was. The caret
-         * is a sibling of the input and so is the tag strip, so pressing the one part
-         * of the control that visibly says "this opens" did nothing at all, and a
-         * reader who wanted the list had to find the text box. Anything drawn inside
-         * the field is the field.
+         * On the field rather than on the `<input>`. The caret is a sibling of the
+         * input and so is the tag strip, so a handler on the input alone leaves the
+         * one part of the control that visibly says "this opens" doing nothing.
+         * Anything drawn inside the field is the field.
          *
          * A tag is the exception, because a tag is its own control: its dismiss
          * removes a choice, and opening the list on the way past would leave the
@@ -604,18 +600,17 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
            is already `Ru` because the browser replaced the selection, and the
            completion is *still* `Ruby`: unchanged, so Lit writes nothing and
            `changed.has('suggestion')` is false, so nothing is selected either. The
-           completion appeared on the first character and never again, which is
-           exactly how it was reported.
+           completion then appears on the first character and never again.
          
            Reconciled against what the input actually holds, which is the only thing
            that knows. */
         const control = this.renderRoot.querySelector('[part="control"]');
         /* The same expression the template binds, because this has to agree with it
-           in both directions. Writing only when there is a completion put the field
-           right while one was showing and left it stale afterwards: this reconcile
-           writes behind Lit's back, so Lit's own dirty-check then believes the DOM
-           already holds whatever it last wrote and declines to correct it. A field
-           cleared on close kept the last completion for exactly that reason. */
+           in both directions. Writing only when there is a completion puts the
+           field right while one is showing and leaves it stale afterwards: this
+           reconcile writes behind Lit's back, so Lit's own dirty-check then
+           believes the DOM already holds whatever it last wrote and declines to
+           correct it. */
         const wanted = this.multiple || this.open ? this.suggestion || this.typed : this.word;
         if (control && control.value !== wanted) {
             control.value = wanted;
@@ -632,12 +627,10 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
                control reopened still narrowed is one whose second use starts from the
                first one's leftovers.
       
-               All three of them, which is the fix. Only the listbox's copy was
-               cleared here, so `typed` survived a dismissal: the field looked empty
-               because a closed single-choice field shows the chosen words instead,
-               and the moment it reopened the old search was back in it with the list
-               behind it showing everything. Measured by pressing Escape on "ru" and
-               opening it again. */
+               All three, not the listbox's copy alone. A surviving `typed` is
+               invisible on close, because a closed single-choice field shows the
+               chosen words instead, and comes back with the list behind it showing
+               everything the moment it reopens. */
             this.typed = '';
             this.suggestion = '';
             this.listbox?.requestFilter('');
@@ -646,12 +639,11 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
     /**
      * The list the field filters, behind a seam the styled tier can move.
      *
-     * A method rather than a fragment inline, so a tier above can render its own,
-     * wrap this one, pass it a property the base does not know about, or leave it
-     * out, without reimplementing the whole template to do any of them. The tag is
+     * A method rather than a fragment inline, so a tier above can replace, wrap
+     * or omit it without reimplementing the whole template. The tag is
      * interpolated rather than written, so `tier` resolves it: this renders the
-     * headless element, and a styled subclass that sets `tier` renders the styled one
-     * from the same template.
+     * headless element, and a styled subclass that sets `tier` renders the styled
+     * one from the same template.
      */
     renderListbox() {
         return html `<${this.tag('listbox')}
@@ -673,21 +665,20 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
     >
       <!-- The field's words are read off the options, and on the first
            render there are none: the slot has not been assigned yet, so a
-           combobox with a value came up empty. Assignment changes no
+           combobox with a value comes up empty. Assignment changes no
            property, so nothing else would schedule the update that fixes
-           it. Select was fixed for exactly this. -->
+           it. -->
       <slot @slotchange=${() => this.requestUpdate()}></slot>
     </${this.tag('listbox')}>`;
     }
     /**
      * One chosen option, as a tag, behind a seam the styled tier can move.
      *
-     * A method rather than a fragment inline, so a tier above can render its own,
-     * wrap this one, pass it a property the base does not know about, or leave it
-     * out, without reimplementing the whole template to do any of them. The tag is
+     * A method rather than a fragment inline, so a tier above can replace, wrap
+     * or omit it without reimplementing the whole template. The tag is
      * interpolated rather than written, so `tier` resolves it: this renders the
-     * headless element, and a styled subclass that sets `tier` renders the styled one
-     * from the same template.
+     * headless element, and a styled subclass that sets `tier` renders the styled
+     * one from the same template.
      */
     renderTag(option) {
         return html `<${this.tag('tag')}
@@ -763,27 +754,15 @@ let HelixHeadlessCombobox = class HelixHeadlessCombobox extends MixinControllerO
 __decorate([
     property()
 ], HelixHeadlessCombobox.prototype, "autocomplete", void 0);
-__decorate([
-    property()
-], HelixHeadlessCombobox.prototype, "placeholder", void 0);
-__decorate([
-    property({ type: Boolean })
-], HelixHeadlessCombobox.prototype, "multiple", void 0);
 __decorate([
     property({ type: Boolean })
 ], HelixHeadlessCombobox.prototype, "creatable", void 0);
-__decorate([
-    property({ type: Boolean })
-], HelixHeadlessCombobox.prototype, "suggest", void 0);
 __decorate([
     property({ attribute: 'create-label' })
 ], HelixHeadlessCombobox.prototype, "createLabel", void 0);
 __decorate([
-    property({ attribute: 'remove-label' })
-], HelixHeadlessCombobox.prototype, "removeLabel", void 0);
-__decorate([
-    property({ attribute: 'max-tags', type: Number })
-], HelixHeadlessCombobox.prototype, "maxTags", void 0);
+    property({ attribute: 'empty-text' })
+], HelixHeadlessCombobox.prototype, "emptyText", void 0);
 __decorate([
     property({ attribute: 'list-label' })
 ], HelixHeadlessCombobox.prototype, "listLabel", void 0);
@@ -794,8 +773,20 @@ __decorate([
     property({ attribute: 'loading-text' })
 ], HelixHeadlessCombobox.prototype, "loadingText", void 0);
 __decorate([
-    property({ attribute: 'empty-text' })
-], HelixHeadlessCombobox.prototype, "emptyText", void 0);
+    property({ attribute: 'max-tags', type: Number })
+], HelixHeadlessCombobox.prototype, "maxTags", void 0);
+__decorate([
+    property({ type: Boolean })
+], HelixHeadlessCombobox.prototype, "multiple", void 0);
+__decorate([
+    property()
+], HelixHeadlessCombobox.prototype, "placeholder", void 0);
+__decorate([
+    property({ attribute: 'remove-label' })
+], HelixHeadlessCombobox.prototype, "removeLabel", void 0);
+__decorate([
+    property({ type: Boolean })
+], HelixHeadlessCombobox.prototype, "suggest", void 0);
 __decorate([
     state()
 ], HelixHeadlessCombobox.prototype, "typed", void 0);

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

@@ -59,14 +59,6 @@ declare const HelixHeadlessCommand_base: (new (...args: any[]) => import("@fusio
  * @csspart listbox-search-field - The field itself.
  */
 export declare class HelixHeadlessCommand extends HelixHeadlessCommand_base {
-    /**
-     * Accessible name for the overlay, which has no visible heading.
-     */
-    label: string;
-    /**
-     * Shown in the field before anything is typed.
-     */
-    placeholder: string;
     /**
      * Words shown where the filter has matched nothing.
      */
@@ -79,6 +71,14 @@ export declare class HelixHeadlessCommand extends HelixHeadlessCommand_base {
      * with: one key, said once.
      */
     hotkey: string;
+    /**
+     * Accessible name for the overlay, which has no visible heading.
+     */
+    label: string;
+    /**
+     * Shown in the field before anything is typed.
+     */
+    placeholder: string;
     /**
      * Whether the consumer put anything under the list.
      *

package/dist/command/root/command-root.js

@@ -87,14 +87,6 @@ const parse = (hotkey) => {
 let HelixHeadlessCommand = class HelixHeadlessCommand extends MixinControllerOpen(HelixElement) {
     constructor() {
         super(...arguments);
-        /**
-         * Accessible name for the overlay, which has no visible heading.
-         */
-        this.label = 'Commands';
-        /**
-         * Shown in the field before anything is typed.
-         */
-        this.placeholder = 'Search commands';
         /**
          * Words shown where the filter has matched nothing.
          */
@@ -107,6 +99,14 @@ let HelixHeadlessCommand = class HelixHeadlessCommand extends MixinControllerOpe
          * with: one key, said once.
          */
         this.hotkey = 'mod+k';
+        /**
+         * Accessible name for the overlay, which has no visible heading.
+         */
+        this.label = 'Commands';
+        /**
+         * Shown in the field before anything is typed.
+         */
+        this.placeholder = 'Search commands';
         /**
          * Whether the consumer put anything under the list.
          *
@@ -199,6 +199,21 @@ let HelixHeadlessCommand = class HelixHeadlessCommand extends MixinControllerOpe
                 this.requestOpen(false);
             }
         };
+        /*
+         * Keeps an option's own announcement inside the palette.
+         *
+         * Every option says `helix-select` when it is chosen, which is how the list
+         * hears it, and the options are light DOM children of this element, so it
+         * carries straight on out to the consumer: two selections for one command
+         * under one event name, told apart only by the target. The one this element
+         * dispatches has itself as the target and is let past.
+         *
+         * `stopImmediatePropagation`, not `stopPropagation`. The consumer's listener
+         * is on this same element, and stopping propagation only keeps an event off
+         * the *next* node, so every other listener already bound here still runs. The
+         * listbox hears it well before this, from inside the shadow root, so nothing
+         * this element needs is lost by ending it here.
+         */
         this.swallowOptionSelect = (event) => {
             if (event.target !== this) {
                 event.stopImmediatePropagation();
@@ -208,25 +223,6 @@ let HelixHeadlessCommand = class HelixHeadlessCommand extends MixinControllerOpe
     get listbox() {
         return this.renderRoot?.querySelector('[part="listbox"]') ?? null;
     }
-    /*
-     * Keeps an option's own announcement inside the palette.
-     *
-     * Every option says `helix-select` when it is chosen, which is how the list
-     * hears it, and the list does not stop it: the options are light DOM children
-     * of this element, so it carried straight on out to the consumer. They then
-     * heard two selections for one command, an option's and the palette's, under
-     * one event name and distinguishable only by looking at the target.
-     *
-     * The one this element dispatches has itself as the target and is let past.
-     * Combobox stops the listbox's `helix-before-change` for the same reason.
-     *
-     * `stopImmediatePropagation`, not `stopPropagation`. The consumer's listener
-     * is on this same element, and stopping propagation only keeps an event off
-     * the *next* node: every other listener already bound here still runs, so the
-     * option's selection reached the consumer anyway. The listbox hears it well
-     * before this, from inside the shadow root, so nothing this element needs is
-     * lost by ending it here.
-     */
     /**
      * The row under the keyboard, read from the attribute the listbox writes.
      *
@@ -332,18 +328,18 @@ let HelixHeadlessCommand = class HelixHeadlessCommand extends MixinControllerOpe
         return html `${this.renderDialog()}`;
     }
 };
-__decorate([
-    property()
-], HelixHeadlessCommand.prototype, "label", void 0);
-__decorate([
-    property()
-], HelixHeadlessCommand.prototype, "placeholder", void 0);
 __decorate([
     property({ attribute: 'empty-text' })
 ], HelixHeadlessCommand.prototype, "emptyText", void 0);
 __decorate([
     property()
 ], HelixHeadlessCommand.prototype, "hotkey", void 0);
+__decorate([
+    property()
+], HelixHeadlessCommand.prototype, "label", void 0);
+__decorate([
+    property()
+], HelixHeadlessCommand.prototype, "placeholder", void 0);
 __decorate([
     state()
 ], HelixHeadlessCommand.prototype, "footed", void 0);