@fusion.dev/helix-core 0.2.0 → 0.4.0

package/dist/events/element-events.js

@@ -1,29 +1,7 @@
-/**
- * Which events each tag actually dispatches, for the React prop audit.
- *
- * **The audit could already tell a name from a typo and not a name from a
- * misplacement.** `helixEventNames` is every event the library has, so
- * `onhelix-resize` written on an element that never fires it read as valid: the
- * name is real, and nothing knew that this element is not the one that sends it.
- * That is the likelier mistake of the two, because it happens while writing a
- * *correct* event name.
- *
- * **Registered rather than imported, because the direction of the tiers forbids
- * the other way round.** This lives in `core`, which is below the packages that
- * define elements and cannot name them. Each package ships a generated call
- * instead, so the map is filled by whoever is loaded and a consumer importing
- * one component is checked against that component.
- *
- * A tag nobody registered is not an error. It is a component from outside this
- * library, or a package built before the generator existed, and the audit says
- * nothing rather than guessing.
- */
 const declared = new Map();
-/** Records the events a set of tags dispatch. Called by generated code. */
 export const registerElementEvents = (entries) => {
     for (const [tag, names] of Object.entries(entries)) {
         declared.set(tag, new Set(names));
     }
 };
-/** The events a tag dispatches, or `undefined` if nothing registered it. */
 export const eventsForTag = (tag) => declared.get(tag);

package/dist/events/events.js

@@ -1,29 +1,3 @@
-/**
- * Event classes, one per event a Helix component dispatches.
- *
- * A named class rather than `dispatchEvent(new CustomEvent(name, …))` for three
- * reasons, all of them about the type reaching a consumer:
- *
- * 1. `@event {HelixBeforeOpenEvent} helix-before-open` puts the class name in the manifest,
- *    which is what lets the React generator emit a typed callback instead of
- *    `(detail: unknown)`.
- * 2. The augmentation of `HTMLElementEventMap` below types `addEventListener`
- *    for consumers writing plain HTML, who never see the React wrappers.
- * 3. The event name lives on the class as `eventName`, so a listener and a
- *    dispatch cannot disagree about the string.
- */
-/**
- * Fired when an element is about to open.
- *
- * Cancelable: `preventDefault()` refuses the change, and the element stays
- * closed. Paired with `helix-before-close` rather than being one event carrying a
- * boolean, so a listener that only cares about one direction says so by which
- * event it listens for.
- *
- * Neither bubbles nor composed. A dialog inside a drawer inside a popover is
- * three overlays, and an inner one opening must not read as the outer one
- * opening.
- */
 export class HelixBeforeOpenEvent extends CustomEvent {
     static { this.eventName = 'helix-before-open'; }
     constructor() {
@@ -35,7 +9,6 @@ export class HelixBeforeOpenEvent extends CustomEvent {
         });
     }
 }
-/** Fired when an element is about to close. See `HelixBeforeOpenEvent`. */
 export class HelixBeforeCloseEvent extends CustomEvent {
     static { this.eventName = 'helix-before-close'; }
     constructor() {
@@ -47,24 +20,6 @@ export class HelixBeforeCloseEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when the reader asks for the next thing in a set.
- *
- * Paired with `helix-previous` rather than being one event carrying a
- * direction, which is the reason `helix-before-open` gives for its own pair: a
- * listener that only cares about one direction says so by which event it
- * listens for. The detail carries the direction anyway, so a consumer who does
- * want one handler can have one.
- *
- * Bubbles and is composed, because the thing that answers this is usually not
- * the thing that asked. A video has no notion of a set: it plays one resource,
- * and what comes next is a playlist's business or the consumer's, so the event
- * has to reach a wrapper.
- *
- * Not cancelable. There is no default action to refuse: the component that
- * fires this does nothing on its own, and an event whose `preventDefault` means
- * nothing is an event that lies about what it offers.
- */
 export class HelixNextEvent extends CustomEvent {
     static { this.eventName = 'helix-next'; }
     constructor() {
@@ -76,7 +31,6 @@ export class HelixNextEvent extends CustomEvent {
         });
     }
 }
-/** Fired when the reader asks for the previous one. See `HelixNextEvent`. */
 export class HelixPreviousEvent extends CustomEvent {
     static { this.eventName = 'helix-previous'; }
     constructor() {
@@ -88,79 +42,29 @@ export class HelixPreviousEvent extends CustomEvent {
         });
     }
 }
-/**
- * A stop asking the tour to move.
- *
- * Composed and bubbling, because a stop is slotted into the root and the root
- * has to hear it across that boundary.
- *
- * **A class rather than a hand-rolled `CustomEvent`.** A dispatch is matched as
- * `new HelixSomethingEvent(`, so a raw `CustomEvent` is not held to being
- * declared and nothing carries it into the manifest: consumers can hear it and
- * cannot find it.
- */
 export class HelixTourAskEvent extends CustomEvent {
     static { this.eventName = 'helix-tour-ask'; }
     constructor(detail) {
         super(HelixTourAskEvent.eventName, {
             bubbles: true,
-            /* Not cancelable. The name says *ask*, so refusing it looks like it should
-               hold the tour, and honoring it here could not work: the root registers
-               its listener in `connectedCallback` and a consumer registers later, so on
-               a bubbling event both are on the same target and the root's runs first,
-               reading `defaultPrevented` before the consumer has had a chance to set
-               it. `helix-shortcut` gets this right by reading the flag on the element
-               that dispatched, where every listener has already run.
-      
-               **The veto exists and is elsewhere.** Moving between stops goes through
-               `requestChange` and announces `helix-before-activate`; leaving early
-               dispatches `helix-before-close` and reads the flag before writing
-               `open`. This event is the stop telling the root a button was pressed,
-               and the decision is taken one step later. */
             cancelable: false,
             composed: true,
             detail,
         });
     }
 }
-/**
- * The eyedropper opening, and closing again.
- *
- * Two events rather than one carrying a flag, because what a consumer does with
- * them is not symmetrical: the surface holding the picker has to get out of the
- * way for the sample and come back afterwards, and those are two moments with
- * different work in each.
- *
- * **A class rather than a bare `Event`.** The check that holds an event to being
- * declared reads `new Event(` as well as `new HelixSomethingEvent(`, so a
- * hand-rolled one is public API a consumer can hear and cannot find.
- *
- * No detail, because there is nothing to say beyond that it happened.
- */
 export class HelixSampleStartEvent extends Event {
     static { this.eventName = 'helix-sample-start'; }
     constructor() {
         super(HelixSampleStartEvent.eventName, { bubbles: true, cancelable: false, composed: true });
     }
 }
-/** The eyedropper closing, whether or not a color was taken. */
 export class HelixSampleEndEvent extends Event {
     static { this.eventName = 'helix-sample-end'; }
     constructor() {
         super(HelixSampleEndEvent.eventName, { bubbles: true, cancelable: false, composed: true });
     }
 }
-/**
- * Fired when an element asks to be taken away.
- *
- * A request rather than a notification: the element does not remove itself,
- * because the consumer owns the markup it is in and removing the node under
- * them would put their state and the document out of step. Cancelable, so
- * `preventDefault()` is a refusal.
- *
- * One verb for both shapes. A tag leaving a list and an announcement closing
- * itself are the same act from the element's side.
- */
 export class HelixDismissEvent extends CustomEvent {
     static { this.eventName = 'helix-dismiss'; }
     constructor(detail) {
@@ -172,25 +76,6 @@ export class HelixDismissEvent extends CustomEvent {
         });
     }
 }
-/**
- * A set is about to make a different child current, and can be refused.
- *
- * **Not a generic `helix-change`.** `Tabs` moving to another tab, `Tree` marking
- * another row and `Steps` advancing are not a value changing, they are a set
- * choosing, and the platform's word for a committed value would say the wrong
- * thing. `active` names which child is current, so `activate` is the verb, and
- * unlike `change` the platform has no claim on it.
- *
- * **This fires before the state moves.** Inside a handler `currentTarget.active`
- * still holds the previous value, and `detail.value` is a proposal another
- * listener may refuse, so a consumer who only wants to know which child is
- * current listens for `helix-activate` instead. `helix-select` is not that
- * notification either: it fires when an item is *chosen*, not when `active` is
- * assigned.
- *
- * The shape is the one `MixinControllerOpen` already has, a cancelable request
- * and a plain notification after the state has moved.
- */
 export class HelixBeforeActivateEvent extends CustomEvent {
     static { this.eventName = 'helix-before-activate'; }
     constructor(detail) {
@@ -202,22 +87,6 @@ export class HelixBeforeActivateEvent extends CustomEvent {
         });
     }
 }
-/**
- * A set has made a different child current.
- *
- * The notification half of `helix-before-activate`, dispatched after the state
- * has moved, so `currentTarget.active` is the new value and the detail is a fact
- * rather than a proposal.
- *
- * **Not cancelable**, for the reason every notification here is not: the
- * decision was taken by the event before it, and a second refusable event for
- * one transition is two answers to one question.
- *
- * **Prefixed, and it has to be.** `activate` unprefixed is not in any
- * `*EventMap` in the DOM library, checked rather than assumed, but the prefix is
- * what stops an event dispatched inside a shadow root and retargeted to the host
- * being mistaken for something the host's own contents sent.
- */
 export class HelixActivateEvent extends CustomEvent {
     static { this.eventName = 'helix-activate'; }
     constructor(detail) {
@@ -229,7 +98,6 @@ export class HelixActivateEvent extends CustomEvent {
         });
     }
 }
-/** A message is about to be pinned or unpinned, and can be refused. */
 export class HelixBeforePinEvent extends CustomEvent {
     static { this.eventName = 'helix-before-pin'; }
     constructor(detail) {
@@ -241,7 +109,6 @@ export class HelixBeforePinEvent extends CustomEvent {
         });
     }
 }
-/** A divider is about to move, and can be refused. */
 export class HelixBeforeResizeEvent extends CustomEvent {
     static { this.eventName = 'helix-before-resize'; }
     constructor(detail) {
@@ -253,13 +120,6 @@ export class HelixBeforeResizeEvent extends CustomEvent {
         });
     }
 }
-/**
- * The divider between a sandbox's panes is about to move, and can be refused.
- *
- * Its own verb rather than a `helix-before-resize` carrying which divider moved:
- * a sandbox has two, and they were told apart by a field on a detail every other
- * request in this file also carries.
- */
 export class HelixBeforeSplitEvent extends CustomEvent {
     static { this.eventName = 'helix-before-split'; }
     constructor(detail) {
@@ -271,14 +131,6 @@ export class HelixBeforeSplitEvent extends CustomEvent {
         });
     }
 }
-/**
- * A sandbox's panel is about to change height, and can be refused.
- *
- * The sibling of `helix-before-split`, and named for the divider rather than for
- * the axis because a reader binding one of the two is choosing which divider they
- * care about. `value` is pixels here and a percentage there, which is what each
- * property already publishes.
- */
 export class HelixBeforePanelResizeEvent extends CustomEvent {
     static { this.eventName = 'helix-before-panel-resize'; }
     constructor(detail) {
@@ -290,7 +142,6 @@ export class HelixBeforePanelResizeEvent extends CustomEvent {
         });
     }
 }
-/** A pane is about to collapse or reopen, and can be refused. */
 export class HelixBeforeCollapseEvent extends CustomEvent {
     static { this.eventName = 'helix-before-collapse'; }
     constructor(detail) {
@@ -302,7 +153,6 @@ export class HelixBeforeCollapseEvent extends CustomEvent {
         });
     }
 }
-/** Source is about to be edited, and can be refused. */
 export class HelixBeforeEditEvent extends CustomEvent {
     static { this.eventName = 'helix-before-edit'; }
     constructor(detail) {
@@ -314,27 +164,6 @@ export class HelixBeforeEditEvent extends CustomEvent {
         });
     }
 }
-/**
- * A value is about to change, and the change can be refused.
- *
- * **The request half of every value control.** It announces the value being
- * *proposed*, before anything moves, so a listener calling `preventDefault()`
- * refuses it and the control stays where it was. That is how a consumer takes
- * one decision without declaring a mode, which is what 294 settled: the element
- * always owns and applies its state, and refusing is the way to take it over.
- *
- * **The notification is native and separate.** Once this has gone out and the
- * value has moved, the control announces it again under the platform's own
- * name, `input` while a reader is editing and `change` when they are done, so
- * `onChange` in React and `onchange=` in HTML both reach it and
- * `currentTarget.value` is correct by the time a handler reads it. This event
- * carries the detail because at the moment it fires the value is not on the
- * element yet.
- *
- * **`announcesInput` picks which native notification fires, not which name this
- * carries.** Granularity is the platform's own distinction, `input` against
- * `change`; the request is always this one event.
- */
 export class HelixBeforeChangeEvent extends CustomEvent {
     static { this.eventName = 'helix-before-change'; }
     constructor(detail) {
@@ -346,24 +175,6 @@ export class HelixBeforeChangeEvent extends CustomEvent {
         });
     }
 }
-/**
- * A checked state is about to change, and the change can be refused.
- *
- * **Its own event rather than a `helix-before-change` carrying a boolean.**
- * Through the value event the state arrives as `String(checked)`, so a consumer
- * receives the string `"false"`, which is truthy, and a test asserting the value
- * passes on that bug. A control whose state is a boolean wants an event with a
- * typed boolean in it.
- *
- * The notification is native, as it is for a value: the control relays `change`
- * from the inner input and announces `input` beside it, so `onChange` reads
- * `currentTarget.checked` and gets a boolean from the platform.
- *
- * It also ends a collision: Checkbox Group listened for its boxes' change and
- * dispatched its own under the same name from the same host, so it needed
- * `stopImmediatePropagation` to keep a consumer from receiving one box's boolean
- * alongside the whole set. Two names, two facts.
- */
 export class HelixBeforeToggleEvent extends CustomEvent {
     static { this.eventName = 'helix-before-toggle'; }
     constructor(detail) {
@@ -375,19 +186,6 @@ export class HelixBeforeToggleEvent extends CustomEvent {
         });
     }
 }
-/**
- * The reader asked for something the list does not hold.
- *
- * Cancelable, and announced before anything is applied, because the options are
- * the consumer's own light DOM and no component here writes into it. What the
- * control can do is say what was asked for and take the value; putting an
- * option in the list, or a row in a database, is the consumer's, and a consumer
- * who validates first refuses this and adds nothing.
- *
- * The detail carries the text as typed, not a slug of it. Trimming or lowering
- * it here would be this element deciding what a name means, and a consumer who
- * wants an identifier can make one from what they were given.
- */
 export class HelixCreateEvent extends CustomEvent {
     static { this.eventName = 'helix-create'; }
     constructor(detail) {
@@ -399,13 +197,6 @@ export class HelixCreateEvent extends CustomEvent {
         });
     }
 }
-/**
- * Something was copied to the clipboard.
- *
- * Not cancelable, and deliberately: it is announced after the write, because a
- * clipboard write is a permission the platform may refuse and there is nothing
- * useful to report until it has either happened or not.
- */
 export class HelixCopyEvent extends CustomEvent {
     static { this.eventName = 'helix-copy'; }
     constructor(detail) {
@@ -416,85 +207,28 @@ export class HelixCopyEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when something being previewed writes to the console.
- *
- * Carries text rather than the logged values. The preview is a separate
- * document, so what arrives has crossed `postMessage` and been through
- * structured clone: a DOM node or a function does not survive that, and half a
- * value is worse than a string of it.
- */
 export class HelixConsoleEvent extends CustomEvent {
     static { this.eventName = 'helix-console'; }
     constructor(detail) {
         super(HelixConsoleEvent.eventName, {
             bubbles: true,
-            /* Not cancelable, for the reason `helix-resize` is not: a log line the
-               frame already wrote is a fact being relayed rather than a proposal, and
-               nothing reads the result. */
             cancelable: false,
             composed: true,
             detail,
         });
     }
 }
-/**
- * Fired when something reports how much room its content actually needs.
- *
- * **A measurement crossing a boundary the measurer is on the far side of.** A
- * sandboxed preview is its own document: nothing outside it can read the height
- * of what it drew, because the frame is opaque and a box sized from the outside
- * only ever reports the box. So the document measures itself and says so, and
- * this is what it says it with.
- *
- * A number rather than a box, because the width is the container's to decide and
- * only the block size follows the content. A consumer that wants to act on it
- * clamps it: what arrives is what was drawn, which for an empty example is
- * nearly nothing and for a long one is more than a page.
- */
 export class HelixResizeEvent extends CustomEvent {
     static { this.eventName = 'helix-resize'; }
     constructor(detail) {
         super(HelixResizeEvent.eventName, {
             bubbles: true,
-            /* Not cancelable. A measurement is not a proposal: the content is that
-               tall whether or not anybody wants it to be, and neither dispatcher,
-               `Heatmap` nor `Sandbox.Preview`, reads the result. Accepting
-               `preventDefault()` and ignoring it is worse than refusing the call, a
-               consumer having every reason to believe they had stopped something. */
             cancelable: false,
             composed: true,
             detail,
         });
     }
 }
-/**
- * Fired when a header crosses the threshold between resting at the top of the
- * page and floating over it.
- *
- * **The threshold lives in a custom state, and is announced rather than
- * reflected.** A `data-scrolled` on the host is an attribute nobody rendered: a
- * server sends the element without it and the element adds it on upgrade, so a
- * framework hydrating the page finds markup that no longer matches what it sent.
- * A custom state is deliberately not in the DOM and therefore not something a
- * hydration pass can disagree with.
- *
- * That closes the observability an attribute would accidentally provide. A
- * `MutationObserver` can watch an attribute and there is no equivalent for
- * `ElementInternals.states`, so a component holding a boolean nothing can read
- * is a component with a private opinion its consumers demonstrably need: the
- * bar's own backdrop is drawn by the page around it, and the page has to know
- * when to light it.
- *
- * Not cancelable. It reports where the page is rather than asking permission to
- * be there, and refusing it would leave the state and the announcement
- * disagreeing.
- *
- * The hysteresis stays inside the header, which is the point of announcing at
- * all: a consumer listening to `scroll` itself would be a second opinion on
- * when the page counts as scrolled, and the two would part company at the eight
- * pixels of travel this waits for.
- */
 export class HelixScrolledEvent extends CustomEvent {
     static { this.eventName = 'helix-scrolled'; }
     constructor(detail) {
@@ -506,18 +240,6 @@ export class HelixScrolledEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when the cursor moves in a text editor.
- *
- * Not cancelable, unlike everything else here. The others announce something
- * about to happen and a listener can refuse it; this one reports where the
- * caret already is, and there is nothing left to refuse.
- *
- * It fires on every keystroke and every arrow press, which is why the status
- * bar reads it from the DOM rather than through a framework's state: routing a
- * caret position through React would re-render the workbench on every cursor
- * move.
- */
 export class HelixCaretEvent extends CustomEvent {
     static { this.eventName = 'helix-caret'; }
     constructor(detail) {
@@ -529,14 +251,6 @@ export class HelixCaretEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when a component moves the view it is showing, rather than its value.
- *
- * A calendar paging to another month is not choosing a date, and the two have
- * to be separable: a consumer driving the view needs to hear that it moved
- * without being told the answer changed. `helix-change` belongs to the value,
- * and giving it both jobs would make either one unusable on its own.
- */
 export class HelixNavigateEvent extends CustomEvent {
     static { this.eventName = 'helix-navigate'; }
     constructor(detail) {
@@ -548,27 +262,6 @@ export class HelixNavigateEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when a control that fills up has filled.
- *
- * The moment a code entry exists for: a six-character field is worth submitting
- * the instant the sixth character lands, and a consumer watching `helix-change`
- * has to know the length and compare it on every keystroke to find that moment
- * themselves.
- *
- * Separate from `helix-change` rather than a flag on it, because they are
- * answered by different code: one keeps a value in step and the other decides
- * whether to send a form. A listener that only cares about the second says so by
- * which event it listens for.
- *
- * `complete` is free as a verb. React's synthetic system claims `change`,
- * `input`, `submit`, `reset`, `copy`, `paste`, `scroll`, `drag`, `focus` and
- * `blur`, measured, and this is none of them.
- *
- * Not cancelable. It reports that something already happened, which is the same
- * reason `helix-caret` is not: there is nothing left to refuse once the last
- * character is in the box.
- */
 export class HelixCompleteEvent extends CustomEvent {
     static { this.eventName = 'helix-complete'; }
     constructor(detail) {
@@ -580,19 +273,6 @@ export class HelixCompleteEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when the reader offers something they wrote.
- *
- * **Cancelable, and the composer clears only when nobody refused.** Sending is a
- * round trip: a composer that empties itself and then hears the request failed
- * has thrown away the only copy of what the reader typed, and a reader who has
- * just written three paragraphs is exactly who cannot afford that. Refusing
- * leaves the text where it is.
- *
- * Not `helix-create`, which is the combobox's event for a value a list does not
- * hold, and not `helix-change`, because nothing about a value changed: the
- * reader finished something and handed it over.
- */
 export class HelixSendEvent extends CustomEvent {
     static { this.eventName = 'helix-send'; }
     constructor(detail) {
@@ -604,20 +284,6 @@ export class HelixSendEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when something a user comes back to is marked read, or unread.
- *
- * **Read state is reported rather than owned.** Marking a notification read is
- * usually a round trip, and a component that flips the state itself and then
- * hears the request failed has already told the reader something untrue. So this
- * is cancelable, and refusing it leaves the item alone; a component left
- * uncontrolled applies it once nobody has refused, which is the same contract
- * every other axis in the library uses.
- *
- * Bubbles and is composed, so a feed hears its own items: one handler on the
- * list serves every notification in it, which is what a consumer syncing to a
- * server actually wants.
- */
 export class HelixReadEvent extends CustomEvent {
     static { this.eventName = 'helix-read'; }
     constructor(detail) {
@@ -629,18 +295,6 @@ export class HelixReadEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when the reader asks for a different order.
- *
- * Cancelable, and refusing it leaves the order alone, which is what makes a
- * server-side sort expressible: the consumer refuses the local reorder, fetches,
- * and hands back a new set. This is the element reporting that a heading was
- * clicked, before it acts on it.
- *
- * Not `helix-change`: nothing about the data changed, only the order it is read
- * in, and a consumer listening for changes to a value should not hear a sort.
- * That is the same distinction `helix-filter` is drawn on.
- */
 export class HelixSortEvent extends CustomEvent {
     static { this.eventName = 'helix-sort'; }
     constructor(detail) {
@@ -652,13 +306,6 @@ export class HelixSortEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when a component narrows what it is showing.
- *
- * Filtering hides rather than removes, so nothing about the value changes and
- * `helix-change` would be a lie. What a consumer wants to know is that the list
- * in front of the reader is no longer the whole list.
- */
 export class HelixFilterEvent extends CustomEvent {
     static { this.eventName = 'helix-filter'; }
     constructor(detail) {
@@ -670,14 +317,6 @@ export class HelixFilterEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when a shortcut's chord is pressed.
- *
- * Cancelable, and the key event is only consumed where this is not refused: a
- * consumer that decides the moment is wrong, a dialog is over the control or
- * the reader is mid-composition, calls `preventDefault()` and the keystroke
- * goes on to whatever would have had it.
- */
 export class HelixShortcutEvent extends CustomEvent {
     static { this.eventName = 'helix-shortcut'; }
     constructor(detail) {
@@ -689,13 +328,6 @@ export class HelixShortcutEvent extends CustomEvent {
         });
     }
 }
-/**
- * Fired when the reader selects an item in a set.
- *
- * Bubbles and is composed, because this is how a set coordinates: a tree, a
- * tab list and a toggle group all learn which of their children was chosen by
- * hearing it arrive.
- */
 export class HelixSelectEvent extends CustomEvent {
     static { this.eventName = 'helix-select'; }
     constructor(detail) {
@@ -707,17 +339,6 @@ export class HelixSelectEvent extends CustomEvent {
         });
     }
 }
-/**
- * Every event this file publishes, and the one place a new one is added.
- *
- * The map below is derived from this rather than written beside it, so a class
- * that is in here is typed and one that is not is absent from both halves at
- * once. Kept by hand the two drifted, and nothing failed when they did: a
- * consumer writing `addEventListener('helix-navigate', …)` got `Event` and had
- * to reach into `detail` through a cast. The build fails on an exported event
- * class left out of this object, which is the only step left that can be
- * forgotten.
- */
 const registry = {
     HelixActivateEvent,
     HelixBeforeActivateEvent,
@@ -752,11 +373,4 @@ const registry = {
     HelixSortEvent,
     HelixTourAskEvent,
 };
-/**
- * Every name this library dispatches.
- *
- * Exported so a runtime check can ask whether a name is one of ours without
- * keeping a second list of them. `HelixElement` uses it to tell a consumer that
- * the handler prop they wrote is attached to nothing.
- */
 export const helixEventNames = new Set(Object.values(registry).map((event) => event.eventName));

package/dist/helix-element/helix-element.d.ts

@@ -88,31 +88,24 @@ export declare class HelixElement extends LitElement {
      * references. An engine without `CustomStateSet` records nothing and keeps
      * whatever the resting rule draws, which is the safe direction to fail.
      *
-     * **Lit's server shim is no longer one of them**, and this said it was.
-     * `@lit-labs/ssr-dom-shim@1.6.0` sets `this.states = new Set()` in its
-     * `ElementInternals` constructor, so the guard passes on the server and a
-     * custom state is recorded where nothing reads it, which is harmless. The
-     * engines the test is for are browsers: Safari below 17.4 and Firefox below
-     * 126. There the write is a `TypeError`, so a component that bypasses this
+     * **The engines the test is for are browsers**: Safari below 17.4 and Firefox
+     * below 126, where the write is a `TypeError`, so a component bypassing this
      * fails to render rather than rendering without whatever the state draws.
+     * Lit's server shim sets `states`, so the guard passes there and records a
+     * state nothing reads, which is harmless.
      */
     protected toggleState(name: string, on: boolean): void;
     /**
      * Resolves a frame after the first update, when transitions are switched on.
      *
-     * **Named `whenSettled` because `settled` was taken four times over.** Image
-     * and Splitter each have a private `settle`, and both color controls carry a
-     * `settled` of their own, all of them older than this and none of them about
-     * transitions. A base class takes the name every subclass then cannot use, so
-     * it takes the one nobody wanted.
+     * **Named `whenSettled` because `settled` is taken four times over**, by
+     * Image, Splitter and both color controls, none of them about transitions. A
+     * base class takes the name every subclass then cannot use.
      *
      * **The state it reports cannot be watched, which is why this exists.** A
-     * `MutationObserver` could see `[data-settled]` arrive and there is no
-     * equivalent for `ElementInternals.states`: a custom state is deliberately not
-     * in the DOM, which is the whole reason it replaced the attribute. Anything
-     * that used to wait on the attribute waits on this instead, and gets a better
-     * signal for it, an awaited promise being what the callers wanted rather than
-     * a mutation they had to interpret.
+     * custom state is deliberately not in the DOM, so there is no
+     * `MutationObserver` equivalent for `ElementInternals.states`. Await this
+     * instead.
      *
      * Separate from `updateComplete`, which resolves in the microtask checkpoint
      * the suppression is still active in. That is the distinction `readyToMove`