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

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

@@ -74,11 +74,11 @@ import '../../menu/index.js';
  * @slot controls - Added to the control bar, before fullscreen.
  * @slot poster - Shown over the video until it starts.
  *
- * @event {Event} ended - Relayed for the same reason.
+ * @event {Event} ended - Relayed, because it does not cross a shadow boundary.
  * @event {HelixNextEvent} helix-next - Fired when the reader asks for the next item.
  * @event {HelixPreviousEvent} helix-previous - Fired when they ask for the previous one.
  * @event {Event} pause - Relayed for the same reason.
- * @event {Event} play - Relayed, because it does not cross a shadow boundary.
+ * @event {Event} play - Relayed for the same reason.
  *
  * @csspart back - The region top left, for a way out of a set.
  * @csspart captions - Subtitles on and off.
@@ -100,7 +100,6 @@ import '../../menu/index.js';
  * @csspart failure - What is said when the source will not play.
  * @csspart forward - The control that goes on ten seconds.
  * @csspart fullscreen - The whole screen, and back.
- * @csspart icon - A glyph this component draws.
  * @csspart loading - What is said while the picture waits for more of itself.
  * @csspart loading-mark - The part of that which spins.
  * @csspart more - The button that opens it.
@@ -136,39 +135,14 @@ import '../../menu/index.js';
  */
 export declare class HelixHeadlessVideo extends HelixElement {
     /**
-     * Where the video is, for the common case of one file.
-     */
-    src: string;
-    /**
-     * A still shown before it plays, which the platform draws itself.
-     */
-    poster: string;
-    /**
-     * Accessible name, since a video is not described by its filename.
-     */
-    label: string;
-    /**
-     * Whether it starts again at the end.
-     */
-    loop: boolean;
-    /**
-     * Whether it *starts* silent, which is what an autoplaying video must do.
+     * Whether it starts on its own, which a browser only allows while silent.
      *
-     * **Renamed from `muted`, because that is what it always was.** The platform
-     * splits these two: the `muted` content attribute reflects to `defaultMuted`,
-     * and the `muted` property is live state a reader's click moves without
-     * touching the attribute. This element declared one property called `muted`,
-     * bound it to the attribute, and tracked the live state privately as
-     * `silent`, so `<helix-video>.muted` answered what the author wrote rather
-     * than whether there was sound. A name matching the platform's while meaning
-     * something else is worse than a name the platform does not have, and
-     * `check:platform-fidelity` could not see it: it compares names.
-     */
-    defaultMuted: boolean;
-    /**
-     * Whether it plays where it sits rather than taking over the screen.
+     * Forwarded rather than acted on. Whether an unprompted play is permitted is
+     * the browser's policy and not this element's, and `play()` already swallows
+     * the refusal: what follows a refused autoplay is a paused player showing its
+     * start control, which is the correct thing to be looking at.
      */
-    playsInline: boolean;
+    autoplay: boolean;
     /**
      * Whether the browser draws the controls instead of this element.
      *
@@ -176,24 +150,22 @@ export declare class HelixHeadlessVideo extends HelixElement {
      * either alone, so this one is not drawn at all when it is set.
      */
     controls: boolean;
-    /**
-     * How much to fetch before anything is asked for.
-     */
-    preload: 'auto' | 'metadata' | 'none';
-    /**
-     * Whether it starts on its own, which a browser only allows while silent.
-     *
-     * Forwarded rather than acted on. Whether an unprompted play is permitted is
-     * the browser's policy and not this element's, and `play()` already swallows
-     * the refusal: what follows a refused autoplay is a paused player showing its
-     * start control, which is the correct thing to be looking at.
-     */
-    autoplay: boolean;
     /**
      * How the media is fetched across origins, which decides whether a track can
      * be read.
      */
     crossOrigin: 'anonymous' | 'use-credentials' | null;
+    /**
+     * Whether it *starts* silent, which is what an autoplaying video must do.
+     *
+     * **Named for the platform's split, which is real.** The `muted` content
+     * attribute reflects to `defaultMuted`; the `muted` property is live state a
+     * reader's click moves without touching the attribute. One property called
+     * `muted` bound to the attribute answers what the author wrote rather than
+     * whether there is sound, which is a name matching the platform's while
+     * meaning something else.
+     */
+    defaultMuted: boolean;
     /**
      * Whether the browser may offer picture in picture.
      */
@@ -202,13 +174,17 @@ export declare class HelixHeadlessVideo extends HelixElement {
      * Whether the browser may offer playback on a remote device.
      */
     disableRemotePlayback: boolean;
+    /**
+     * And what they are told when it will not play at all.
+     */
+    errorLabel: string;
     /**
      * Controls beyond the ones every player has, named in the order they appear.
      *
      * A list rather than a property apiece. A bar is a row with a budget, and a
      * boolean per feature invites a consumer to switch all of them on: naming
      * them makes the row a decision, and makes the order theirs. Anything
-     * unrecognised is skipped rather than throwing, since the list is markup and
+     * unrecognized is skipped rather than throwing, since the list is markup and
      * a typo should cost a control, not a page.
      *
      * `pip` is offered only where the platform has it, checked rather than
@@ -225,6 +201,30 @@ export declare class HelixHeadlessVideo extends HelixElement {
      * and not something a player can work around.
      */
     extraControls: string;
+    /**
+     * How long the bar waits after the pointer stops before it goes, in ms.
+     *
+     * A wait rather than leaving with the pointer, or a reader moving across the
+     * picture to reach a control watches the bar vanish under them. Zero turns
+     * the wait off and the bar goes immediately; a large number keeps it up for
+     * as long as anyone is likely to look.
+     *
+     * The wait is only ever about *idling*. A video that is paused keeps its bar
+     * regardless, because a reader who stopped it is deciding what to do next.
+     */
+    idleDelay: number;
+    /**
+     * Accessible name, since a video is not described by its filename.
+     */
+    label: string;
+    /**
+     * What a reader is told while the picture is waiting for more of itself.
+     */
+    loadingLabel: string;
+    /**
+     * Whether it starts again at the end.
+     */
+    loop: boolean;
     /**
      * Controls that go behind one button instead of onto the bar, named the same
      * way.
@@ -244,28 +244,13 @@ export declare class HelixHeadlessVideo extends HelixElement {
      */
     overflowControls: string;
     /**
-     * The big mark over the picture before anything has played, or `none`.
-     *
-     * **On unless it is turned off, because a stopped video has nothing else.**
-     * Measured on the bar as it was: the play glyph is 16 by 16 in a 24 by 24
-     * target, which is 0.12% of a 528 by 396 picture and 0.33% at 320. What a
-     * reader meets first is a still frame with some chrome along the bottom, and
-     * nothing in it says "press to watch".
-     *
-     * `none` is for the cases where that is wrong rather than right: a muted loop
-     * behind a hero, a grid of eight thumbnails, anything where the video is
-     * decoration rather than something to start.
-     *
-     * **Only before the first play.** A video paused halfway already has its bar
-     * up, because a paused video never idles, so the small control is visible and
-     * the reader has just used it. Covering the picture they stopped to look at
-     * would be the opposite of helpful.
-     *
-     * A value rather than a boolean, so the resting state is the attribute's
-     * absence: a boolean defaulting to on would have to be spelled as its own
-     * negation.
+     * And while it would stop it.
      */
-    startControl?: 'none';
+    pauseLabel: string;
+    /**
+     * What the play control is called while it would start the video.
+     */
+    playLabel: string;
     /**
      * Whether the file this points at is ours to hand over.
      *
@@ -277,37 +262,43 @@ export declare class HelixHeadlessVideo extends HelixElement {
      */
     private get localFile();
     /**
-     * The speeds offered, slowest first, as multipliers of normal.
+     * Whether it plays where it sits rather than taking over the screen.
      */
-    speeds: string;
+    playsInline: boolean;
     /**
-     * How long the bar waits after the pointer stops before it goes, in ms.
-     *
-     * It used to leave the moment the pointer did, which is not how a player
-     * behaves: a reader moving across the picture to reach a control watched it
-     * vanish under them. Zero turns the wait off and the bar goes immediately;
-     * a large number keeps it up for as long as anyone is likely to look.
-     *
-     * The wait is only ever about *idling*. A video that is paused keeps its bar
-     * regardless, because a reader who stopped it is deciding what to do next.
+     * A still shown before it plays, which the platform draws itself.
      */
-    idleDelay: number;
+    poster: string;
     /**
-     * What the play control is called while it would start the video.
+     * How much to fetch before anything is asked for.
      */
-    playLabel: string;
+    preload: 'auto' | 'metadata' | 'none';
     /**
-     * And while it would stop it.
+     * The speeds offered, slowest first, as multipliers of normal.
      */
-    pauseLabel: string;
+    speeds: string;
     /**
-     * What a reader is told while the picture is waiting for more of itself.
+     * Where the video is, for the common case of one file.
      */
-    loadingLabel: string;
+    src: string;
     /**
-     * And what they are told when it will not play at all.
+     * The big mark over the picture whenever it is not playing, or `none`.
+     *
+     * **On unless it is turned off, because a stopped video has nothing else.**
+     * Measured on the bar as it was: the play glyph is 16 by 16 in a 24 by 24
+     * target, which is 0.12% of a 528 by 396 picture and 0.33% at 320. What a
+     * reader meets first is a still frame with some chrome along the bottom, and
+     * nothing in it says "press to watch".
+     *
+     * `none` is for the cases where that is wrong rather than right: a muted loop
+     * behind a hero, a grid of eight thumbnails, anything where the video is
+     * decoration rather than something to start.
+     *
+     * A value rather than a boolean, so the resting state is the attribute's
+     * absence: a boolean defaulting to on would have to be spelled as its own
+     * negation.
      */
-    errorLabel: string;
+    startControl?: 'none';
     /**
      * Whether playback has stopped to wait for data.
      *
@@ -344,12 +335,11 @@ export declare class HelixHeadlessVideo extends HelixElement {
     /**
      * How many caption tracks there are, which decides which control is drawn.
      *
-     * A count and not a boolean, and that is the whole reason it changed. Tracks
-     * resolve after the element renders, so this is what schedules the update
-     * that draws the control at all; as a boolean it went false to true when the
-     * first one arrived and then never moved again, so a second track landing
-     * left the toggle in place and the language menu was unreachable on exactly
-     * the videos it exists for.
+     * A count and not a boolean. Tracks resolve after the element renders, so
+     * this is what schedules the update that draws the control at all, and a
+     * boolean goes false to true when the first track arrives and then never
+     * moves again: a second one landing leaves the toggle in place and the
+     * language menu unreachable on exactly the videos it exists for.
      */
     private captionCount;
     /**
@@ -401,13 +391,9 @@ export declare class HelixHeadlessVideo extends HelixElement {
     /**
      * The media's own state, under the platform's own names.
      *
-     * **This element already knew every one of these and kept them private.** It
-     * tracks `currentTime` as `position`, `duration` as `knownDuration`, `volume`
-     * as `loudness`, `paused` as `playing` and `playbackRate` as `rate`, paints
-     * them, and published none of them, so a consumer asking where the video had
-     * reached had nowhere to ask: the `<video>` is inside this shadow root and
-     * `querySelector` does not cross it. 295 is that finding across the library
-     * and this is its clearest case.
+     * **Published because there is no other way in.** The `<video>` is inside
+     * this shadow root and `querySelector` does not cross it, so a consumer
+     * asking where the video has reached has nowhere else to ask.
      *
      * **Read from the element, with the mirror as the fallback.** The element is
      * the truth and the mirror is a render cache that a media event refreshes, so
@@ -490,10 +476,9 @@ export declare class HelixHeadlessVideo extends HelixElement {
      * name Video never promised, carrying a seconds count or a level between zero
      * and one rather than anything about the element.
      *
-     * Found by sweeping every family that renders a native control, which is what
-     * 308 said and not what it was read as: the first two passes both took "form
-     * control" as the population and a media component with two rails in its
-     * chrome is neither a form control nor exempt from the mechanism. See 308.
+     * Every family that renders a native control needs this, not only the form
+     * controls: a media component with two rails in its chrome is neither a form
+     * control nor exempt from the mechanism.
      */
     private takeScrub;
     /** The volume rail's new level, stopped for the reason `takeScrub` carries. */
@@ -509,13 +494,6 @@ export declare class HelixHeadlessVideo extends HelixElement {
     private readonly handleMedia;
     private readonly handleLoaded;
     private readonly handleTime;
-    /**
-     * Relayed, because none of these cross a shadow boundary on their own.
-     *
-     * The video is inside this element's shadow root, so a consumer listening on
-     * the element they wrote hears nothing at all without this. Input relays
-     * `change` for the same reason.
-     */
     private readonly handleWaiting;
     private readonly handleReady;
     private readonly handleError;
@@ -623,11 +601,11 @@ export declare class HelixHeadlessVideo extends HelixElement {
      * user activation. Both are `TypeError: Permissions check failed`, which is
      * the same message for two different causes.
      *
-     * It was `void`ed, so a refusal became an unhandled rejection: the button did
-     * nothing and said nothing, and the console entry it left named neither the
-     * element nor the reason. Caught here, the state stays honest because
-     * `aria-pressed` follows `fullscreenchange` rather than this call, so a
-     * refused request leaves a button that correctly reports "not fullscreen".
+     * Caught rather than `void`ed, or a refusal becomes an unhandled rejection
+     * naming neither the element nor the reason. The state stays honest either
+     * way, because `aria-pressed` follows `fullscreenchange` rather than this
+     * call, so a refused request leaves a button that correctly reports "not
+     * fullscreen".
      */
     private toggleFullscreen;
     /**
@@ -662,9 +640,8 @@ export declare class HelixHeadlessVideo extends HelixElement {
      *
      * Because CSS cannot ask. `paused` is a property of a `<video>` and never an
      * attribute, so `video:not([paused])` matches every video that has ever
-     * existed: the first version of the rule that hides the bar used exactly that
-     * and hid it always, including on a paused video, which is the one state it
-     * was written to keep it in.
+     * existed and a rule written on it hides the bar always, including on the
+     * paused video it was written to keep the bar up for.
      *
      * **A `data-` attribute is right here because of when it is written.** A fact
      * that can be true on the first update mirrors to a custom state instead, or
@@ -672,9 +649,8 @@ export declare class HelixHeadlessVideo extends HelixElement {
      * React reports a mismatch it will not patch up. Nothing plays until somebody
      * presses play, so this one is written long past hydration and there is
      * nothing for it to disagree with. `data-closed` on `Toast.Item` and
-     * `data-closed` on `Toast.Item` is the same case; `:state(open)` and
-     * `:state(checked)` are the other one, and were `data-` attributes until
-     * 27 Aug 2026.
+     * `data-scrolled` on `AppHeader` are the same case; `:state(open)` and
+     * `:state(checked)` are the other one.
      */
     protected updated(changed: PropertyValues): void;
     /**