@fusion.dev/helix 0.157.0 → 0.159.0

package/types/vue.d.ts

@@ -244,9 +244,9 @@ import type {
   HelixBeforeResizeEvent,
   HelixCollapseEvent,
   HelixResizedEvent,
+  HelixLoadEvent,
   HelixTourAskEvent,
   HelixTourStatusEvent,
-  HelixLoadEvent,
   HelixEndEvent,
   HelixNextEvent,
   HelixPreviousEvent,
@@ -565,6 +565,15 @@ export type HelixAppHeaderElementEvent<E = Event> = TypedEvent<
   HelixAppHeader,
   E
 >;
+/** `toggle` event type */
+export type HelixAppHeaderToggleElementEvent =
+  HelixAppHeaderElementEvent<ToggleEvent>;
+/** `helix-before-close` event type */
+export type HelixAppHeaderHelixBeforeCloseElementEvent =
+  HelixAppHeaderElementEvent<HelixBeforeCloseEvent>;
+/** `helix-before-open` event type */
+export type HelixAppHeaderHelixBeforeOpenElementEvent =
+  HelixAppHeaderElementEvent<HelixBeforeOpenEvent>;
 /** `helix-scrolled` event type */
 export type HelixAppHeaderHelixScrolledElementEvent =
   HelixAppHeaderElementEvent<HelixScrolledEvent>;
@@ -622,6 +631,23 @@ It pairs with `material`: a bar that does not stick is only ever over the
 top of the page, so `glass` and `transparent` have nothing to be
 translucent against and the `scrolled` state never lands. */
   sticky?: (HelixAppHeader["sticky"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  "default-open"?: (HelixAppHeader["defaultOpen"]) | undefined;
+  /** Whether the element starts open. Ignored once `open` is written. */
+  defaultOpen?: (HelixAppHeader["defaultOpen"]) | undefined;
+  /** Whether the element is open.
+
+One property, not two, so `dialog.open` answers the question anyone
+asking it meant. Writing always applies; `<helix-dialog open>` is the
+same statement in markup.
+
+**Not reflected, and that is required rather than tidy.** Reflection
+writes the resolved state back as an attribute, so an element that opened
+itself would put `open` on its own host: cloned, serialized for
+hydration, or diffed by a framework, it comes back holding whatever the
+last reader did rather than what the author wrote. `:state(open)` carries
+the resolved state for stylesheets, which is what the mirror is for. */
+  open?: (HelixAppHeader["open"]) | undefined;
   /** Where the middle region sits in the bar.
 
 Centered by default, which reads as the site's spine when the navigation is
@@ -669,9 +695,27 @@ page scrolls up. */
   /** The id of the element whose scrolling lifts the bar, for an app shell that
 scrolls a container instead of the window. Unset is the window. */
   scroller?: (HelixAppHeader["scroller"]) | undefined;
+  /** Where the toggle that opens a folded middle region sits: at the end of the
+bar, after the trailing content, or with `start`, before the leading
+content.
+
+Optional, so the resting bar writes no attribute onto the host. */
+  "toggle-placement"?: (HelixAppHeader["togglePlacement"]) | undefined;
+  /** Where the toggle that opens a folded middle region sits: at the end of the
+bar, after the trailing content, or with `start`, before the leading
+content.
+
+Optional, so the resting bar writes no attribute onto the host. */
+  togglePlacement?: (HelixAppHeader["togglePlacement"]) | undefined;
 };
 
 export type HelixAppHeaderVueEvents = {
+  /** The folded region opened or closed. The event carries `newState` and `oldState`. */
+  toggle: HelixAppHeaderToggleElementEvent;
+  /** The folded region is about to close. Cancelable: cancel it to keep it open. */
+  "helix-before-close": HelixAppHeaderHelixBeforeCloseElementEvent;
+  /** The folded region is about to open. Cancelable: cancel it to keep it closed. */
+  "helix-before-open": HelixAppHeaderHelixBeforeOpenElementEvent;
   /** Fired when the page crosses the scroll threshold, with the new state. A custom state cannot be observed the way an attribute can, so listen for this event to follow it. The event uses the header's own threshold and hysteresis, so you do not need a second scroll listener. */
   "helix-scrolled": HelixAppHeaderHelixScrolledElementEvent;
 };
@@ -1642,6 +1686,14 @@ separate actions. The semantics and the joining are separate questions:
 `role="group"` and a shared name are what make a set of buttons a set, and
 `helix-flex` gives the spacing without the group. */
   variant?: (HelixButtonGroup["variant"]) | undefined;
+  /** Keeps at least one button pressed once one is, as React Aria's
+`disallowEmptySelection`: a press that would leave none pressed is
+refused. */
+  "disallow-empty-selection"?: (HelixButtonGroup["disallowEmptySelection"]) | undefined;
+  /** Keeps at least one button pressed once one is, as React Aria's
+`disallowEmptySelection`: a press that would leave none pressed is
+refused. */
+  disallowEmptySelection?: (HelixButtonGroup["disallowEmptySelection"]) | undefined;
   /** The group's name, read by screen readers.
 
 On the host through internals, so an author's `aria-label` still overrides
@@ -5211,6 +5263,13 @@ how many are left, written in the locale, and each language writes the
 forms it has: `{count, plural, one {# polecenie} few {# polecenia} many
 {# poleceń} other {# polecenia}}`. */
   resultsLabel?: (HelixCommand["resultsLabel"]) | undefined;
+  /** Whether a command is kept by the filter: a function given the command's
+words and the filter, trimmed, that returns `true` to keep it showing, as
+React Aria's `Autocomplete` takes `filter`. See Listbox's `filterMatch`.
+
+Absent, a command is kept where its words hold the filter, in any case. A
+property only, there being no way to write a function in markup. */
+  filterMatch?: (HelixCommand["filterMatch"]) | undefined;
   /** The commands as data, for a palette too long to draw whole: each a value,
 which is also its words, or a record with a `value`, a `label` and
 `disabled`. Handed to the list, which draws only the commands in sight and
@@ -10237,7 +10296,9 @@ Not reflected, as a state never is. `row-current` is the part a
 stylesheet draws it from. */
   current?: (HelixListItem["current"]) | undefined;
   /** Takes the row out of reach in a list with `selection-mode`: the arrow keys
-pass over it and it cannot be selected or acted on. */
+pass over it and it cannot be selected or acted on. In a list with
+`disabled-behavior="selection"`, it cannot be selected and is reached and
+acted on as any row is. */
   disabled?: (HelixListItem["disabled"]) | undefined;
   /** The URL the row links to. Leave it empty for a row that is not a link.
 
@@ -10273,6 +10334,10 @@ being moved, or the one the drop indicator is beside. Unset otherwise. */
 Written by the list from its own `value`, and unset where nothing can be
 selected, which keeps `aria-selected` off a list that does not select. */
   selected?: (HelixListItem["selected"]) | undefined;
+  /** Whether `disabled` takes the row out of selection alone, written by a list
+with `disabled-behavior="selection"`. No attribute: it is coordination
+between elements, as `focusable` is. */
+  selectionOnly?: (HelixListItem["selectionOnly"]) | undefined;
 };
 
 export type HelixListItemVueEvents = {
@@ -10322,6 +10387,20 @@ refused, in a `reorderable` list. */
   /** What screen readers hear when a held row is put back, or a move is
 refused, in a `reorderable` list. */
   canceledLabel?: (HelixList["canceledLabel"]) | undefined;
+  /** What `disabled` takes from a row, in a list that selects: `all`, which
+passes over the row, or `selection`, which keeps the row out of the
+selection and lets the keys reach it and Enter or a press act on it, as
+React Aria's GridList takes `disabledBehavior`.
+
+Absent is `all`. */
+  "disabled-behavior"?: (HelixList["disabledBehavior"]) | undefined;
+  /** What `disabled` takes from a row, in a list that selects: `all`, which
+passes over the row, or `selection`, which keeps the row out of the
+selection and lets the keys reach it and Enter or a press act on it, as
+React Aria's GridList takes `disabledBehavior`.
+
+Absent is `all`. */
+  disabledBehavior?: (HelixList["disabledBehavior"]) | undefined;
   /** What screen readers hear when a row is dropped, in a `reorderable` list. */
   "dropped-label"?: (HelixList["droppedLabel"]) | undefined;
   /** What screen readers hear when a row is dropped, in a `reorderable` list. */
@@ -10706,6 +10785,14 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixListbox["name"]) | undefined;
+  /** Whether an option is kept by the filter: a function given the option's
+words and the filter, trimmed, that returns `true` to keep it showing, as
+React Aria's `Autocomplete` takes `filter`. For matching that ignores
+accents, matches the start of each word, or matches out of order.
+
+Absent, an option is kept where its words hold the filter, in any case. A
+property only, there being no way to write a function in markup. */
+  filterMatch?: (HelixListbox["filterMatch"]) | undefined;
   /** The options as data, for a list too long to draw whole: each a value,
 which is also its words, or a record with a `value`, a `label` and
 `disabled`. Set, the list draws only the options in sight, and the ones
@@ -12643,8 +12730,11 @@ imperatively later, and nothing is hydrating by then.
 
 Here rather than on each control. */
   name?: (HelixNumberInput["name"]) | undefined;
-  /** The value as a number, or `NaN` while the control is empty.
+  /** The value as a number, or `NaN` while the control is empty or does not
+hold a number.
 
+Read in the locale and the format, as the form reads it, so `1,5` typed
+in a locale with a decimal comma is 1.5 here while the form holds 1.5.
 `NaN` and not zero, which is the trap the platform already avoids: `Number('')`
 is zero, so an empty control would report a number it does not hold and a
 form would submit it. */
@@ -15407,7 +15497,8 @@ control height until you size it, with a height on the element or
   /** What is loading, read out as the placeholder's name, such as "Loading
 profile".
 
-Absent hides the placeholder from screen readers. */
+Absent hides the placeholder from screen readers. Around content, the name
+is read while `loading` is set, and the loaded content is read as it is. */
   label?: (HelixSkeleton["label"]) | undefined;
   /** Whether the content inside is still loading, which keeps it inert and
 draws the placeholder over it.
@@ -16999,7 +17090,16 @@ known by its place among the rows as written. */
 
 export type HelixTableRowVueEvents = {};
 
+/** `HelixTabPanel` component event */
+export type HelixTabPanelElementEvent<E = Event> = TypedEvent<HelixTabPanel, E>;
+/** `helix-load` event type */
+export type HelixTabPanelHelixLoadElementEvent =
+  HelixTabPanelElementEvent<HelixLoadEvent>;
+
 export type HelixTabPanelVueProps = {
+  /** Whether the panel's content waits in a `<template>` until the panel is
+first shown. */
+  lazy?: (HelixTabPanel["lazy"]) | undefined;
   /** Whether this panel is the visible one. */
   selected?: (HelixTabPanel["selected"]) | undefined;
   /** Pairs the panel with the tab of the same value. */
@@ -17017,7 +17117,10 @@ the pattern names one anyway. */
   label?: (HelixTabPanel["label"]) | undefined;
 };
 
-export type HelixTabPanelVueEvents = {};
+export type HelixTabPanelVueEvents = {
+  /** Fired the first time a `lazy` panel is shown, once its template's content is in. */
+  "helix-load": HelixTabPanelHelixLoadElementEvent;
+};
 
 /** `HelixTabs` component event */
 export type HelixTabsElementEvent<E = Event> = TypedEvent<HelixTabs, E>;
@@ -18505,6 +18608,12 @@ consumer's server markup does not have. A sheet carries the resting
 arrangement in its own `:host` rule and the selectors describe only the
 departures, which is what `orientation` does. */
   placement?: (HelixToast["placement"]) | undefined;
+  /** The edge a touch or a pen swipes a message toward to dismiss it: `end`,
+the end of the line, or `start`, `top` or `bottom`. Unset is `end`. */
+  "swipe-direction"?: (HelixToast["swipeDirection"]) | undefined;
+  /** The edge a touch or a pen swipes a message toward to dismiss it: `end`,
+the end of the line, or `start`, `top` or `bottom`. Unset is `end`. */
+  swipeDirection?: (HelixToast["swipeDirection"]) | undefined;
 };
 
 export type HelixToastVueEvents = {
@@ -19058,6 +19167,14 @@ The shape is `Carousel`'s, which is the nearest thing in the library: a
   "next-label"?: (HelixTour["nextLabel"]) | undefined;
   /** Label for the control that goes on. */
   nextLabel?: (HelixTour["nextLabel"]) | undefined;
+  /** What a press outside the current stop and its target does while the tour
+runs. Unset, nothing: the page stays usable. `close` ends the tour, as
+Skip does, and `block` refuses the press. */
+  "outside-press"?: (HelixTour["outsidePress"]) | undefined;
+  /** What a press outside the current stop and its target does while the tour
+runs. Unset, nothing: the page stays usable. `close` ends the tour, as
+Skip does, and `block` refuses the press. */
+  outsidePress?: (HelixTour["outsidePress"]) | undefined;
   /** Draws each stop's place in the run in its panel, as well as saying it. */
   progress?: (HelixTour["progress"]) | undefined;
   /** Each stop's place in the run, with `{index}` and `{count}` filled in and
@@ -19146,6 +19263,9 @@ heading. */
 Reflected, because the styled tier places a dialog and a floating panel by
 it, and unset at rest, so no default is written onto the host. */
   type?: (HelixTourStop["type"]) | undefined;
+  /** Run as the tour reaches the stop, before it is shown: see the description
+above. A function, so it is set from script and has no attribute. */
+  effect?: (HelixTourStop["effect"]) | undefined;
 };
 
 export type HelixTourStopVueEvents = {
@@ -22523,6 +22643,8 @@ export type CustomCssProperties = {
   "--toast-duration"?: (string) | undefined;
   /** How far a swipe has moved the message across, in pixels, toward the right. */
   "--toast-swipe-x"?: (string) | undefined;
+  /** How far a swipe has moved the message down, in pixels, under a `swipe-direction` of `top` or `bottom`. */
+  "--toast-swipe-y"?: (string) | undefined;
   /** Space between one message and the next. */
   "--toast-gap"?: (string) | undefined;
   /** Width of a message. */