@fusion.dev/helix-headless 0.4.2 → 0.4.3

package/dist/app-header/root/app-header-root.d.ts

@@ -5,37 +5,17 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  *
  * @description
  * Tracks whether the page has scrolled and carries it as the custom state
- * `scrolled`, so the styled tier can lift the bar off the page without a scroll
- * handler of its own. Scroll position is the one piece of state the server
- * genuinely cannot know, so it is read on connect rather than derived: a fresh
- * load starts at the top, which is what the server rendered, and a reload
- * part-way down corrects on hydration.
+ * `scrolled`, so the styled tier can lift the bar without a scroll handler of
+ * its own. It is read on connect rather than derived: a fresh load starts at
+ * the top, which is what the server rendered, and a reload part-way down
+ * corrects on hydration.
  *
  * **A custom state and never `data-scrolled`.** An attribute the element writes
  * onto its own host is one the server did not send, so a hydrating framework
- * reports the tree as mismatched, intermittently: only when the reader reloads
- * far enough down the page to pass the threshold. A consumer can answer that
- * only by suppressing hydration warnings on an element they did not write.
- * `ElementInternals.states` is deliberately not in the DOM, so there is nothing
- * for a hydration pass to disagree with, and `:state(scrolled)` selects it. The
- * base class made the same move for `data-settled` and its note explains the
- * rest.
- *
- * The listener is passive and reads `scrollY` only, so it never blocks
- * scrolling.
- *
- * Three regions, each in its own wrapper, because the row is a grid and a grid
- * needs three items to put the middle one in the middle. A bare slot is
- * `display: contents`, so its assigned elements become grid items themselves:
- * two actions would take two tracks and push the navigation off center. These
- * wrappers earn their boxes, which is the test; they carry no inset or fill of
- * their own, so an empty one still paints nothing.
- *
- * The host is the banner and spans the viewport; the row inside it is what gets
- * centered. A banner that is itself narrowed leaves its background stopping
- * short of the window edges, which reads as a floating bar rather than as the
- * top of the page. That needs one element and one row, not a wrapper as well:
- * the host carries the material and `content` carries the measure.
+ * reports a mismatch, intermittently: only when the reader reloads far enough
+ * down the page. `ElementInternals.states` is not in the DOM, so there is
+ * nothing for a hydration pass to disagree with, and `:state(scrolled)` selects
+ * it.
  *
  * @since 0.1.0
  * @status stable

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

@@ -15,40 +15,15 @@ export declare const FOLDS_UP_TO = 12;
  *
  * @description
  * A part of `Avatar` rather than a family of its own: it arranges avatars and
- * is about nothing else, and its member is a complete `Avatar` the group did
- * not have to explain.
+ * is about nothing else.
  *
  * **The overflow count is the group's, not a slot.** Which avatars are hidden
- * is a fact the group works out from `max` and how many it was given, so a
- * consumer writing the "+3" themselves would be writing a number that has to
- * agree with a list they do not control.
+ * is a fact the group works out from `max`, so a consumer writing the "+3"
+ * would be writing a number that has to agree with a list they do not control.
  *
- * **Hidden, not removed.** Past `max`, the extra avatars stay in the DOM and
+ * **Hidden, not removed.** Past `max` the extra avatars stay in the DOM and
  * stop being shown, so nothing re-renders when `max` changes and the accessible
- * name can still be built from all of them. The count is what a sighted reader
- * gets; the group's own name is what everyone else gets, and "Seven people" is
- * more useful than seven names read in a row.
- *
- * **And hidden by the stylesheet, not by this class.** Hiding from `updated` is
- * one update too late and one element too far out: Lit renders on a microtask,
- * so an avatar appended past the limit is laid out and painted before anything
- * runs to hide it, and marking each one means writing attributes onto markup a
- * consumer owns. The styled tier's
- * `:host([max="N"]) ::slotted(:nth-child(n + N+1))` is right at the first style
- * resolution and writes nothing.
- *
- * **The fold is finite, and the count agrees with it.** `An+B` takes a literal,
- * so there is one selector per value of `max` and the range stops at twelve.
- * Past that the group shows everyone, counts nothing and says so, because
- * showing everyone is a defensible answer and showing everyone beside a "+5" is
- * not. `max` above twelve is a list the consumer should be slicing themselves.
- *
- * **It is a list.** A row of faces is a set of separate people, and a group
- * with no role announces as one run of text. `role="list"` needs its children
- * to be `listitem`, which they cannot be told to become without writing an
- * attribute onto a consumer's element, so the group carries `role="group"` and
- * its name instead: one announcement, correct, and nothing written to anyone
- * else's markup.
+ * name is still built from all of them.
  *
  * @since 0.1.0
  * @status stable

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

@@ -4,37 +4,18 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @summary Shows the path to the current page.
  *
  * @description
- * The host is the landmark, so `aria-label` on it names the trail directly and
- * there is no property mirroring one. A page may hold more than one navigation,
- * and landmarks are how a screen-reader user chooses between them.
+ * The host is the landmark, so `aria-label` on it names the trail directly. A
+ * page may hold more than one navigation, and landmarks are how a
+ * screen-reader user chooses between them.
  *
- * `role="list"` is set explicitly on the `<ol>` even though it is already a
- * list: removing the markers with `list-style: none` strips list semantics in
- * Safari, and a breadcrumb trail always removes its markers.
+ * `role="list"` is set explicitly on the `<ol>` even though it is one:
+ * `list-style: none` strips list semantics in Safari, and a breadcrumb trail
+ * always removes its markers.
  *
- * Items are slotted rather than wrapped, so they are `<ol>` children in the flat
- * tree and each carries `role="listitem"` itself.
+ * Items are slotted rather than wrapped, so they are `<ol>` children in the
+ * flat tree and each carries `role="listitem"` itself.
  *
- * **The trail does not measure itself, and the overflow is markup.** Measuring
- * how many crumbs fit can never reach the server: there is no width without a
- * DOM, so the server ships every crumb and the client removes some after
- * hydrating, and a trail that collapses paints wrong on every single load. Nor
- * does anybody specify a breadcrumb in units of fit. Designs say "keep the root
- * and the current page, fold the middle", which is a fact about depth, or "fold
- * below this width", which is a fact CSS knows.
- *
- * So the trail lays out crumbs and separators, and the consumer writes what
- * folds: a `helix-menu` of `helix-menu-item`s in a crumb, where the gap
- * belongs. Server rendered, no observer, no stylesheet, and correct before the
- * first script runs. A trail that should fold only at some widths is a
- * container query in the consumer's own sheet, which is theirs to write and
- * theirs to leave out.
- *
- * **And the crumbs carry no marker for any of it.** CSS can already see it: the
- * crumb with the menu in it is `:has(helix-menu)`, and the middle is
- * `:not(:first-child, [current])`. A marker would be the design rule written
- * twice, once in the HTML and once in the sheet, with nothing keeping the two
- * honest.
+ * **The trail does not measure itself, and the overflow is markup.**
  *
  * @since 0.1.0
  * @status stable

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

@@ -7,35 +7,16 @@ declare const HelixHeadlessChat_base: (new (...args: any[]) => import("@fusion.d
  *
  * @description
  * **It has no opinion about where it sits.** A chat is asked for as a floating
- * button, a page, a palette, a sidebar, a modal and an inline block, and none of
- * those is a variant of a conversation: they are containers a conversation is
- * put in, and the containers already exist. `Popover` and `SpeedDial` make the
- * floating one, `Drawer` the sidebar, `Dialog` the modal, `Command` the palette,
- * and a page is a page. Nothing here is positioned, nothing here has a backdrop,
- * and nothing here owns a trigger, because a trigger opens a container and
- * containers own their own. If a form factor needs a mode on this element, the
- * split is wrong.
+ * button, a page, a palette, a sidebar, a modal and an inline block, and none
+ * of those is a variant of a conversation: they are containers, and the
+ * containers already exist. Nothing here is positioned, nothing has a backdrop,
+ * and nothing owns a trigger. If a form factor needs a mode on this element,
+ * the split is wrong.
  *
- * **Scroll ownership is the behavior everything else depends on, and it is the
- * most-got-wrong thing in the category.** A transcript that grows wants to stay
- * at the bottom, except when the reader has scrolled up to read, where pinning
- * is hostile. The rule: pin while the reader is within `threshold` of the
- * bottom, release the moment they leave it, and offer a way back. **Never scroll
- * a reader who is reading.**
- *
- * The element owns it, because it is the only party that knows a message arrived
- * and where the viewport was when it did. `pinned` announces before it moves, so
- * a consumer who wants to own it refuses the request and assigns their own.
- *
- * **The live region announces on completion, not on arrival.** The transcript is
- * `role="log"` with `aria-live="polite"`, and a streaming message carries
- * `aria-busy` while it arrives: a screen reader reading a stream token by token
- * is unusable, and holding the announcement until the flag clears is the only
- * arrangement that works. Somebody typing is a separate status region, so it
- * never interleaves with what was said.
- *
- * **Not a client.** No transport, no protocol, no model. It renders a
- * conversation and reports what the reader did.
+ * **Scroll ownership is the behavior everything else depends on.** A transcript
+ * that grows wants to stay at the bottom, except when the reader has scrolled
+ * up to read, where pinning is hostile. The rule: pin while the reader is
+ * within `threshold` of the bottom, and let go the moment they leave it.
  *
  * @since 0.1.0
  * @status experimental

package/dist/color-picker/root/color-picker-root.d.ts

@@ -9,38 +9,20 @@ declare const HelixHeadlessColorPicker_base: (new (...args: any[]) => import("@f
  * @summary Picks a color, from a square and two ramps.
  *
  * @description
- * **The picker itself, with no field around it.** Color Input is this element in
- * a panel behind a text field, the same way Date Input is `helix-date-picker` in a
- * panel: a form wants a field, and a settings pane or a toolbar wants the picker
- * sitting flat on the page with nothing to open. Neither should be the other one
- * with parts hidden.
+ * **The picker itself, with no field around it.** Color Input is this element
+ * in a panel behind a text field; a settings pane or a toolbar wants the picker
+ * flat on the page with nothing to open.
  *
- * **The square is two real range inputs.** Saturation and brightness are each an
- * `<input type="range">`, laid over the square and made invisible, and the
- * handle is drawn from their values. The pointer gets the square; the keyboard
- * gets the arrow keys, Home, End and the page keys; a screen reader gets two
- * sliders that announce a name and a number. All of it is the platform's, and
- * nothing here implements a key handler. There is no `role="application"`, which
- * is the usual way this control is built and amounts to asking a screen reader
- * to stop helping.
+ * **The square is two real range inputs.** Saturation and brightness are each
+ * an `<input type="range">`, laid over the square and made invisible, and the
+ * handle is drawn from their values. The keyboard, the announcements and the
+ * touch targets are the platform's, and there is no `role="application"`.
  *
  * **The working model is HSB, and the value is derived from it.** The reverse
  * loses colors: black is `brightness: 0`, whose hue and saturation are both
- * undefined, so a reader who drags to the bottom of the square and back would
- * get gray where they had red. Holding the model means a color survives a trip
- * through one that has no hue. A value arriving from outside is read into the
- * model once, which is the only moment the conversion runs in that direction.
- *
- * **Every syntax is read; the one `format` names is written.** `#f00`,
- * `#ff0000`, `rgb(255 0 0)`, `rgba(255,0,0,.5)` and `hsl(0 100% 50%)` are all
- * colors. Named colors are the exception, and deliberately: resolving
- * `rebeccapurple` means shipping a table of a hundred and forty or asking the
- * browser, and there is no browser during a server render.
- *
- * The properties below are written by this component and read by whoever draws
- * it. A consumer sets none of them: they carry a number this element computed
- * and CSS cannot, which is what lets a stylesheet on this tier draw the thing
- * without measuring anything itself.
+ * undefined, so dragging to the bottom of the square and back would give gray
+ * where there had been red. A value arriving from outside is read into the
+ * model once.
  *
  * @since 0.1.0
  * @status experimental

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

@@ -7,73 +7,31 @@ declare const HelixHeadlessCombobox_base: (new (...args: any[]) => import("@fusi
  * @summary A field that filters a list as it is typed into.
  *
  * @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. 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 list is `helix-listbox`, and the filtering is its own.** It owns
+ * narrowing, the empty state, the highlight, `aria-activedescendant` and
+ * scrolling an option into view. 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
- * option they then choose, and the field is rewritten to that option's words
- * once they have. A combobox that treated the typing as the value would submit
- * "jav" to a form, which is the mistake a plain input makes and the reason this
- * component exists.
- *
- * 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.
+ * **The text and the value are two things.** What a reader types is a filter:
+ * it narrows the list and is thrown away. The value is whichever option they
+ * then choose, and the field is rewritten to that option's words once they
+ * have. The filter is cleared on close, so a reopened control does not start
+ * from the last visit's leftovers.
  *
  * **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
- * public `navigate`: the moving, the wrapping, the skipping of disabled options
- * and the seeding from the current value all stay in the one place that already
- * does them.
- *
- * `role="combobox"` on the input rather than on a wrapper, because the thing
- * the pattern describes is the text field, and `aria-controls` can name the
- * listbox because both are in this shadow root. The active option cannot be
- * named that way, being the consumer's light DOM, so it is linked by element
- * reference for the reason Listbox records at length.
- *
- * **With `multiple`, the chosen options are tags in the field.** A field that
- * says "Rust, Ruby, Go" is a sentence the reader has to parse to find out what
- * is in it, and offers nothing to press to take one out: Select does that today
- * and it is the weakest part of it. A tag apiece is one object per answer, each
- * with its own remove control, which is what the reader already believes they
- * are looking at.
+ * arrows move the list without leaving the text, through the listbox's public
+ * `navigate`. `role="combobox"` is on the input rather than on a wrapper,
+ * because the thing the pattern describes is the text field.
  *
- * The panel stays open while more than one can be chosen, because a control
- * that shut after each pick is one the reader has to reopen to keep using. The
- * filter clears on each choice instead, so the next pick starts from the whole
- * list rather than from the last search.
+ * **With `multiple`, the chosen options are tags in the field**, one object per
+ * answer, each with its own remove control. The panel stays open while more
+ * than one can be chosen and the filter clears on each choice, so the next pick
+ * starts from the whole list.
  *
  * **`creatable` announces, and does not write.** The options are the consumer's
  * light DOM and nothing here puts an element into it: a component that grew the
- * consumer's markup would be a component their framework re-renders over. What
- * this does is offer a row saying what would be added, take the value when the
- * reader presses it, and say so with `helix-create`. A consumer who has to
- * validate first refuses the event and adds nothing.
- *
- * Which leaves a value naming no option, and that is what the words fall back
- * to: for anything chosen the field shows the option's text if there is one and
- * the value itself otherwise. No copy is stored, so a consumer who then adds a
- * real option with that value has its words take over on the next render.
- *
- * **`suggest` finishes the word, and only ever forwards.** The field completes
- * to the first option the typing begins, with the part the reader did not type
- * selected, so the next character replaces it and Delete removes it. Applied on
- * insertion alone: completing after a deletion would put back what the reader
- * just took out, and a field that cannot be shortened is a field that cannot be
- * corrected. Measured as the difference between `insertText` and the several
- * `delete*` input types, which is what the platform already says about which
- * happened.
- *
- * The filter stays what was typed rather than what was completed. Filtering on
- * the completion would narrow the list to the one option it came from, so a
- * reader typing "ru" would be shown "Rust" alone and never learn Ruby was
- * there.
+ * consumer's markup would be one their framework re-renders over. It offers the
+ * row and fires the event; adding the option is the consumer's.
  *
  * @since 0.1.0
  * @status experimental

package/dist/copy-button/root/copy-button-root.d.ts

@@ -7,29 +7,14 @@ import '../../tooltip/index.js';
  * @description
  * **The confirmation is the component.** Writing to the clipboard is three
  * lines; what makes this worth an element is that the platform gives a reader
- * no feedback at all. A press that copies and looks identical to a press that
- * failed is a control nobody trusts, so they press it again, and the second
- * press is indistinguishable from the first.
+ * no feedback at all, so a press that copies looks identical to one that
+ * failed.
  *
  * **Announced after the write, never before.** A clipboard write is a
- * permission the browser may refuse, and it is refused for real reasons: an
- * insecure origin, a document that is not focused, a user agent that requires a
- * gesture this press did not qualify as. So the confirmation and the event both
- * wait for the promise, and a refusal leaves the button exactly as it was.
- * `HelixCopyEvent` is not cancelable for the same reason: by the time there is
- * anything to say, it has already happened.
- *
- * **An icon button, extending IconButton.** Both of this button's faces are
- * icons and it never carries a word, so it is the square control rather than a
- * text button that happens to hold a glyph: it inherits the square box, and
- * with it the rule that an icon-only control must be named. `label` is not
- * optional here for the same reason it is not optional there, and the two
- * faces make it sharper: the accessible name has to describe the press, not
- * whichever picture is showing when a reader arrives.
- *
- * `data-copied`, not a reflected `copied`. State never reflects here: a
- * serialized `copied` attribute would come back from a paste as a button
- * claiming to have copied something it never held.
+ * permission the browser may refuse, for real reasons: an insecure origin, a
+ * document that is not focused, a gesture that did not qualify. The
+ * confirmation and the event both wait for the promise, and a refusal leaves
+ * the button exactly as it was.
  *
  * @since 0.1.0
  * @status experimental

package/dist/data-table/root/data-table-root.d.ts

@@ -9,10 +9,9 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  *
  * @description
  * **The schema is markup and the data is a property.** Columns are declared as
- * `helix-table-column` children, because a schema is small, declarative, and
- * something a reader should be able to see in the HTML; rows are handed over as
- * an array, because data is large and a table that draws ten thousand elements
- * cannot window them.
+ * `helix-table-column` children, because a schema is small and something a
+ * reader should see in the HTML; rows are handed over as an array, because a
+ * table that draws ten thousand elements cannot window them.
  *
  * ```html
  * <helix-data-table .rows=${rows} sort="name:asc" page-size="20">
@@ -25,35 +24,13 @@ declare const HelixHeadlessDataTable_base: (new (...args: any[]) => import("@fus
  * twelve things a person wrote out.
  *
  * **Sort and filter apply to the whole set, never the page.** Sorting the drawn
- * window is correct on the first screen and wrong on every other one, which is
- * how it survives being looked at. The arithmetic lives in `order.ts` where
- * nothing can see a window, and its spec asserts the composition rather than the
- * three steps, because each step alone passes either way.
+ * window is correct on the first screen and wrong on every other one.
  *
- * **What it does not do, stated where a consumer will read it: the cell values
- * do not server-render.** The headings do, because a column renders its own, and
- * the row elements do, because their count comes from `rows`. Reading a cell
- * needs the columns, and the columns are markup children that Lit SSR does not
- * hand this element: `children` is undefined there. So a crawler and a reader on
- * a slow connection see a table of the right shape with nothing in it, which is
- * strictly less than `helix-table` serves for a table whose rows are markup.
- *
- * That is the cost of "the schema is markup and the data is a property". Use
- * `helix-table` where the content has to be in the served HTML and the result is
- * small enough to write out; use this where the result is large, and accept that
- * the first paint is a shell. The obvious workaround, a `columns` property
- * beside the markup columns, is deliberately not offered: it splits one source
- * of truth for the columns into two that nothing checks against each other, and
- * a table rendering one way on the server and another in the browser is that
- * failure with a hydration mismatch on top.
- *
- * **Every axis is controlled or uncontrolled, and that is what makes a server
- * mode fall out rather than be bolted on.** `sort`, `filter`, `page` and
- * `page-size` each defer to the consumer when set and seed themselves from a
- * `default-*` when not. A consumer who answers all four holds the data flow:
- * they hear the reader's request, fetch, and hand back a new `rows` with a
- * `total`. Retrofitting that inverts the flow and is a rewrite, so it is here
- * from the start.
+ * **The cell values do not server-render.** The headings do, and the row
+ * elements do, but reading a cell needs the columns, and the columns are markup
+ * children Lit SSR does not hand this element. So a crawler sees a table of the
+ * right shape with nothing in it. That is the cost of the first paragraph: use
+ * `helix-table` where the served HTML has to carry the values.
  *
  * @since 0.1.0
  * @status experimental

package/dist/date-input/root/date-input-root.d.ts

@@ -9,29 +9,13 @@ declare const HelixHeadlessDateInput_base: (new (...args: any[]) => import("@fus
  * @description
  * **The calendar is `helix-date-picker`, not a second one written here.** It
  * already knows about months, ranges, disabled days, the first day of the week
- * and every keyboard rule a grid owes a reader, and a picker that reimplemented
- * a tenth of that would be a worse grid that also had to be maintained. This
- * element is the field, the overlay, and the translation between them.
+ * and every keyboard rule a grid owes a reader. This element is the field, the
+ * overlay, and the translation between them.
  *
- * **Typed as well as picked, and the typing is the reason it is not
+ * **Typed as well as picked, and the typing is why it is not
  * `<input type="date">`.** The native control gives a free picker and a free
- * locale and takes almost all styling with it, which is a fair trade until a
- * product needs the calendar to match everything around it. What is kept from
- * the native one is the part worth keeping: a real text field, so a reader who
- * knows the date types it and never opens anything.
- *
- * **The value is `YYYY-MM-DD`, always.** That is what a form submits, what
- * `min` and `max` compare against, and what the calendar speaks. What the field
- * *shows* is the same string: a locale-formatted display would have to be parsed
- * back on every keystroke, and half-typed input does not survive a round trip
- * through a formatter. The same reasoning the sandbox records for its two
- * syntaxes, which is that a document being edited must not be a rendering of
- * something else.
- *
- * **Opening does not commit.** The calendar announces a date, this element takes
- * it, and the overlay shuts, because a single date has nothing more to say. A
- * consumer who owns `value` answers the announcement the way they answer any
- * other control here.
+ * locale and takes almost all styling with it. What is kept from it is the part
+ * worth keeping: a real text field.
  *
  * @since 0.1.0
  * @status experimental

package/dist/date-picker/root/date-picker-root.d.ts

@@ -6,44 +6,19 @@ declare const HelixHeadlessDatePicker_base: (new (...args: any[]) => import("@fu
  *
  * @description
  * A grid of days, per the APG date grid: the whole grid is one tab stop, arrows
- * move by day and week, `PageUp` and `PageDown` move by month, and `Home` and
- * `End` go to the ends of the week. Only the focused cell is in the tab
- * sequence.
+ * move by day and week, `PageUp` and `PageDown` by month, `Home` and `End` to
+ * the ends of the week. Only the focused cell is in the tab sequence.
  *
- * Roving `tabindex` is written on the cells, which is free here because they
- * are rendered into this shadow root rather than being markup a consumer wrote.
+ * **Dates are `YYYY-MM-DD` strings and every calculation is in UTC.** A
+ * local-time `Date` shifts across a timezone or a daylight-saving boundary.
  *
- * Dates are `YYYY-MM-DD` strings and every calculation is in UTC. A local-time
- * `Date` shifts across a timezone or a daylight-saving boundary, so the string
- * is what the component holds and the arithmetic never leaves UTC.
+ * `month` is what the grid shows, separately from `value`, so paging does not
+ * select anything and a consumer can drive the view. Left unset it follows the
+ * first selected date, then the current month.
  *
- * `month` is what the grid shows, separately from `value`, so paging through
- * months does not select anything and a consumer can drive the view. Left
- * unset, it follows the first selected date, and then the current month.
- *
- * `mode` decides how many dates are held. Absent takes one. `range` takes two
- * and marks everything between them, starting over on the third click rather
- * than replacing an end at random. `multiple` toggles, so clicking a chosen
- * date takes it out. All three read and write the same comma-separated
- * `value`.
- *
- * `locale` is worth setting where the output is compared across environments.
- * Left unset, month and day names come from the runtime's own locale, and a
- * server and a browser need not agree on what that is.
- *
- * A control whose value changes dispatches `helix-before-change`:
- * `Input`, `Select`, `Listbox`, `Radio.Group` and `Toggle.Group` all do, and a
- * calendar submitting a date is the same kind of thing. `helix-select` stays
- * what it is elsewhere, which is a row or an item being chosen in something
- * that reports no value at all, such as `Menu` or `Tree`.
- *
- * Paging is `helix-navigate` and not either of those, because it chooses
- * nothing: the view moves and the answer does not.
- *
- * The properties below are written by this component and read by whoever draws
- * it. A consumer sets none of them: they carry a number this element computed
- * and CSS cannot, which is what lets a stylesheet on this tier draw the thing
- * without measuring anything itself.
+ * `mode` decides how many dates are held: absent takes one, `range` takes two
+ * and marks everything between them, `multiple` toggles. All three read and
+ * write the same comma-separated `value`.
  *
  * @since 0.1.0
  * @status experimental

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

@@ -7,37 +7,15 @@ declare const HelixHeadlessDialog_base: (new (...args: any[]) => import("@fusion
  * @description
  * A real `<dialog>` opened with `showModal()`, not a div with a role and a
  * hand-built trap. The platform gives four things that are each a day's work to
- * reimplement and easy to get subtly wrong: the top layer, so the dialog is
- * above everything regardless of what `z-index` anyone else wrote; a real
- * backdrop; Escape; and inert-behind, so the page underneath is not reachable
- * by pointer, keyboard, or a screen reader's virtual cursor.
+ * reimplement: the top layer, so the dialog is above everything whatever
+ * `z-index` anyone wrote; a real backdrop; Escape; and inert-behind, so the
+ * page underneath is unreachable by pointer, keyboard or virtual cursor.
  *
  * **`open` drives `showModal()`, and every way it can close comes back through
- * `requestOpen`.** A native dialog can close from three directions: the
- * property, Escape, and a `<form method="dialog">` submit inside it. Left
- * alone, two of those would shut the dialog while the consumer's state still
- * said open, which is the bug that makes a modal impossible to reopen. Escape
- * is intercepted and routed through the request, so `preventDefault()` on the
- * `helix-before-close` refuses it; a close that happens anyway is reflected back.
- *
- * **Nothing here traps focus.** `showModal()` does it, and better: `inert` on
- * the rest of the document is something no JavaScript trap can achieve.
- * `FocusTrapController` stays for the surfaces that are not modal.
- *
- * The regions are bare slots rather than wrappers, for the reason the card's
- * are: an unassigned `<slot>` is `display: contents` and generates no box, so a
- * dialog with no footer has no empty band where one would be.
- *
- * Opened declaratively with the platform's invoker attributes:
- *
- * ```html
- * <helix-button commandfor="confirm" command="--show">Delete…</helix-button>
- * <helix-dialog id="confirm">…</helix-dialog>
- * ```
- *
- * `--show`, `--close` and `--toggle`. Custom commands rather than the built-in
- * `show-modal`, because those are defined against native elements and do
- * nothing when pointed at a custom one.
+ * `requestOpen`.** A native dialog closes from three directions: the property,
+ * Escape, and a `<form method="dialog">` submit. Left alone, two of them would
+ * shut the dialog while the consumer's state still said open, which is the bug
+ * that makes a modal impossible to reopen.
  *
  * @since 0.1.0
  * @status stable

package/dist/donut-chart/root/donut-chart-root.d.ts

@@ -9,32 +9,12 @@ declare const HelixHeadlessDonutChart_base: typeof HelixElement & (new (...args:
  * The chart with the narrowest honest use, so the component is narrow too.
  *
  * **It reads one column and treats the rows as the parts.** Every other chart
- * here takes a column per series; a ring has one whole to divide, and a second
- * ring inside the first is two charts sharing a picture in the most literal
- * way. So the first column of numbers is the series and each row is a slice.
+ * here takes a column per series; a ring has one whole to divide, so the first
+ * column of numbers is the series and each row is a slice.
  *
- * **It refuses negative values rather than drawing them.** A share of a whole
- * cannot be less than nothing, and an arc for a negative number either runs
- * backwards over its neighbors or is silently dropped. Those rows are skipped
- * and the total is of what is left, which is the only reading that stays true.
- *
- * **The shape is drawn with a dashed stroke, not with arc commands.** One
- * `<circle>` per slice, its dash set to the slice's share of the circumference
- * and its offset to where the slice begins. Arc paths need the sweep flag and a
- * large-arc flag, both of which flip at values a reader never sees coming, and
- * a slice of exactly one whole becomes a path with no length at all.
- *
- * **And it keeps its aspect ratio**, alone among the charts here. The others
- * set `preserveAspectRatio="none"` so one drawing fills any box and rescue
- * their strokes with `vector-effect`; that rescues strokes and not geometry, so
- * a ring drawn the same way is an ellipse in anything but a square.
- *
- * The table is the accessible representation and this drawing is `aria-hidden`.
- *
- * The properties below are written by this component and read by whoever draws
- * it. A consumer sets none of them: they carry a number this element computed
- * and CSS cannot, which is what lets a stylesheet on this tier draw the thing
- * without measuring anything itself.
+ * **It refuses negative values rather than drawing them.** An arc for a
+ * negative number either runs backwards over its neighbors or is silently
+ * dropped. Those rows are skipped and the total is of what is left.
  *
  * @since 0.1.0
  * @status experimental