@fusion.dev/helix-core 0.145.0 → 0.146.0

package/dist/controllers/virtualize-controller/virtualize-controller.d.ts

@@ -20,7 +20,9 @@ export interface VirtualizeOptions {
      * the straight line the note below defends. A host that returns its row
      * elements gets each one measured after it renders and placed by what it
      * came to; a host that returns nothing gets every item at `estimate`, which
-     * is right whenever the rows really are uniform and is cheaper.
+     * is right whenever the rows really are uniform and is cheaper. A host that
+     * returns its rows and turns `measured` off keeps the straight line, with its
+     * slope read once from the rows it drew.
      *
      * **Each row carries its own index rather than being counted off from
      * `window.first`.** A host is free to place its rows whenever it likes, and
@@ -129,6 +131,15 @@ export declare class VirtualizeController implements ReactiveController {
     private readonly heights;
     /** Room `shift` added above the window, owed to the scroll offset once drawn. */
     private owed;
+    /**
+     * The drawn rows' height on the straight line, read once per estimate.
+     *
+     * Undefined until a host that offers `rows` has drawn some on the uniform
+     * path, and again after `forget`.
+     */
+    private sample;
+    /** The length of the set when `endInSight` last answered true. */
+    private askedAt;
     constructor(host: ReactiveControllerHost, options: VirtualizeOptions);
     hostConnected(): void;
     hostDisconnected(): void;
@@ -145,6 +156,28 @@ export declare class VirtualizeController implements ReactiveController {
     measure(): void;
     /** The straight line: one estimate, so offset and index convert by division. */
     private uniform;
+    /**
+     * How tall one item is on the straight line: the drawn rows' height once
+     * read, and `estimate` until then.
+     *
+     * **An estimate that is wrong on the straight line leaves the end of the
+     * set out of reach.** Rows of 21 pixels placed at 32 fill two thirds of the
+     * room they are counted for, so the window stops short of the bottom of the
+     * box and the spacer after it holds the rest: in Chromium, `scrollToIndex`
+     * on the last of 5,000 such rows scrolled to the end and drew nothing there.
+     * Reading the drawn rows once corrects the slope, and it is still a line.
+     */
+    private line;
+    /**
+     * Reads the drawn rows' height once for the straight line, for a host that
+     * offers `rows` and does not measure.
+     *
+     * The mean of the rows drawn, each item's elements counted together. A row
+     * with no height, such as one that is not laid out, says nothing. When the
+     * line moves, the scroll offset moves with it, so the item at the top of the
+     * box stays there.
+     */
+    private sampleRows;
     /** Whether this pass places by measurement: offered, and wanted. */
     private measuring;
     /**
@@ -176,6 +209,20 @@ export declare class VirtualizeController implements ReactiveController {
      * host draws around the rows.
      */
     remaining(): number;
+    /**
+     * Whether a reader has come within one screen of the end of the set, true
+     * once for each length of it.
+     *
+     * For a host that asks for more items as a reader nears the end: it sends
+     * its request when this answers true, and the set growing lets it answer
+     * true again. False while the box has no height or the set no items, so a
+     * list that has not been laid out asks for nothing.
+     *
+     * `length` is what the answer is kept for, the count by default. A host
+     * whose count is a filtered view of what it holds passes what it holds, so
+     * new items that the filter hides still let it ask again.
+     */
+    endInSight(length?: number): boolean;
     /**
      * The two spacers' heights for the window, with item `kept` drawn too.
      *

package/dist/controllers/virtualize-controller/virtualize-controller.js

@@ -8,6 +8,7 @@ export class VirtualizeController {
         this.warned = false;
         this.window = { after: 0, before: 0, first: 0, last: 0 };
         this.owed = 0;
+        this.askedAt = -1;
         this.handleScroll = () => {
             this.settling = 0;
             this.measure();
@@ -46,7 +47,7 @@ export class VirtualizeController {
         this.watch();
         const box = this.options.container();
         const total = Math.max(0, this.options.count());
-        const size = Math.max(1, this.options.estimate());
+        const size = this.line();
         if (!box) {
             return;
         }
@@ -80,6 +81,36 @@ export class VirtualizeController {
         const last = Math.min(total, first + fits);
         return { after: Math.max(0, (total - last) * size), before: first * size, first, last };
     }
+    line() {
+        const estimate = Math.max(1, this.options.estimate());
+        return this.sample?.estimate === estimate ? this.sample.size : estimate;
+    }
+    sampleRows() {
+        const estimate = Math.max(1, this.options.estimate());
+        if (this.sample?.estimate === estimate) {
+            return;
+        }
+        const heights = new Map();
+        for (const { element, index } of this.options.rows?.() ?? []) {
+            heights.set(index, (heights.get(index) ?? 0) + element.getBoundingClientRect().height);
+        }
+        const seen = [...heights.values()].filter((height) => height > 0);
+        if (seen.length === 0) {
+            return;
+        }
+        const was = this.line();
+        const size = Math.max(1, seen.reduce((sum, height) => sum + height, 0) / seen.length);
+        this.sample = { estimate, size };
+        if (Math.abs(size - was) < 0.5) {
+            return;
+        }
+        const box = this.options.container();
+        if (box && box.scrollTop > 0) {
+            box.scrollTop = (box.scrollTop / was) * size;
+        }
+        this.settling = 0;
+        this.measure();
+    }
     measuring() {
         return this.options.rows !== undefined && (this.options.measured?.() ?? true);
     }
@@ -107,7 +138,7 @@ export class VirtualizeController {
         const top = Math.max(0, box.scrollTop);
         const bottom = top + box.clientHeight;
         if (!this.measuring()) {
-            const size = Math.max(1, this.options.estimate());
+            const size = this.line();
             const first = Math.min(Math.floor(top / size), total);
             return { first, last: Math.max(first, Math.min(total, Math.ceil(bottom / size))) };
         }
@@ -124,11 +155,21 @@ export class VirtualizeController {
         if (!box) {
             return 0;
         }
-        const length = this.measuring()
-            ? this.heights.total(total)
-            : total * Math.max(1, this.options.estimate());
+        const length = this.measuring() ? this.heights.total(total) : total * this.line();
         return Math.max(0, length - Math.max(0, box.scrollTop) - box.clientHeight);
     }
+    endInSight(length = Math.max(0, this.options.count())) {
+        const screen = this.options.container()?.clientHeight ?? 0;
+        if (length === 0 ||
+            screen <= 0 ||
+            this.askedAt === length ||
+            this.options.count() <= 0 ||
+            this.remaining() > screen) {
+            return false;
+        }
+        this.askedAt = length;
+        return true;
+    }
     spacers(kept) {
         const { after, before, first, last } = this.window;
         if (kept === undefined || (kept >= first && kept < last)) {
@@ -149,6 +190,7 @@ export class VirtualizeController {
             this.owed = 0;
         }
         if (!this.measuring()) {
+            this.sampleRows();
             return;
         }
         const rows = this.options.rows?.();
@@ -190,7 +232,7 @@ export class VirtualizeController {
         this.owed += room;
     }
     sizeOf(index) {
-        return this.measuring() ? this.heights.at(index) : Math.max(1, this.options.estimate());
+        return this.measuring() ? this.heights.at(index) : this.line();
     }
     reveal(index, inset = 0, { align = 'nearest', behavior } = {}) {
         const box = this.options.container();
@@ -231,10 +273,11 @@ export class VirtualizeController {
         const total = Math.max(0, this.options.count());
         return this.measuring()
             ? this.heights.before(index, total)
-            : Math.max(0, Math.min(index, total)) * Math.max(1, this.options.estimate());
+            : Math.max(0, Math.min(index, total)) * this.line();
     }
     forget() {
         this.heights.forget();
+        this.sample = undefined;
     }
     report() {
         if (this.warned) {

package/dist/events/action.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A reader acted on a row: Enter on a list row, or a press in a list that
+ * selects nothing. Sent from the row, so `target` is the row acted on.
+ *
+ * Carries nothing, because the row is the whole of the answer. Not cancelable:
+ * a row with a link follows it and sends nothing, so there is no default left
+ * to refuse.
+ */
+export declare class HelixActionEvent extends Event {
+    static readonly eventName = "helix-action";
+    constructor();
+}

package/dist/events/action.js

@@ -0,0 +1,6 @@
+export class HelixActionEvent extends Event {
+    static { this.eventName = 'helix-action'; }
+    constructor() {
+        super(HelixActionEvent.eventName, { bubbles: true, cancelable: false, composed: true });
+    }
+}

package/dist/events/activate.d.ts

@@ -0,0 +1,22 @@
+import type { ActivateDetail } from './details.js';
+/**
+ * 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. `previous` is the value that was current before, where
+ * the set knows it, as Web Awesome's `wa-video-change` carries both.
+ *
+ * **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 declare class HelixActivateEvent extends CustomEvent<ActivateDetail> {
+    static readonly eventName = "helix-activate";
+    constructor(detail: ActivateDetail);
+}

package/dist/events/activate.js

@@ -0,0 +1,11 @@
+export class HelixActivateEvent extends CustomEvent {
+    static { this.eventName = 'helix-activate'; }
+    constructor(detail) {
+        super(HelixActivateEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/aura-fallback.d.ts

@@ -0,0 +1,12 @@
+import type { AuraFallbackDetail } from './details.js';
+/**
+ * An aura stopped drawing its shader and shows its gradient, and says why.
+ *
+ * Sent each time it falls back, from the aura, which then matches
+ * `:state(fallback)` until it draws again. Not cancelable: there is nothing
+ * left to refuse.
+ */
+export declare class HelixAuraFallbackEvent extends CustomEvent<AuraFallbackDetail> {
+    static readonly eventName = "helix-aura-fallback";
+    constructor(detail: AuraFallbackDetail);
+}

package/dist/events/aura-fallback.js

@@ -0,0 +1,11 @@
+export class HelixAuraFallbackEvent extends CustomEvent {
+    static { this.eventName = 'helix-aura-fallback'; }
+    constructor(detail) {
+        super(HelixAuraFallbackEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-activate.d.ts

@@ -0,0 +1,24 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * 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 declare class HelixBeforeActivateEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-activate";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-activate.js

@@ -0,0 +1,11 @@
+export class HelixBeforeActivateEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-activate'; }
+    constructor(detail) {
+        super(HelixBeforeActivateEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-change.d.ts

@@ -0,0 +1,26 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * 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 declare class HelixBeforeChangeEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-change";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-change.js

@@ -0,0 +1,11 @@
+export class HelixBeforeChangeEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-change'; }
+    constructor(detail) {
+        super(HelixBeforeChangeEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-close.d.ts

@@ -0,0 +1,6 @@
+import type { OpenDetail } from './details.js';
+/** Fired when an element is about to close. See `HelixBeforeOpenEvent`. */
+export declare class HelixBeforeCloseEvent extends CustomEvent<OpenDetail> {
+    static readonly eventName = "helix-before-close";
+    constructor();
+}

package/dist/events/before-close.js

@@ -0,0 +1,11 @@
+export class HelixBeforeCloseEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-close'; }
+    constructor() {
+        super(HelixBeforeCloseEvent.eventName, {
+            bubbles: false,
+            cancelable: true,
+            composed: false,
+            detail: { open: false },
+        });
+    }
+}

package/dist/events/before-collapse.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeDetail } from './details.js';
+/** A pane is about to collapse or reopen, and can be refused. */
+export declare class HelixBeforeCollapseEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-collapse";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-collapse.js

@@ -0,0 +1,11 @@
+export class HelixBeforeCollapseEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-collapse'; }
+    constructor(detail) {
+        super(HelixBeforeCollapseEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-edit.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeDetail } from './details.js';
+/** Source is about to be edited, and can be refused. */
+export declare class HelixBeforeEditEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-edit";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-edit.js

@@ -0,0 +1,11 @@
+export class HelixBeforeEditEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-edit'; }
+    constructor(detail) {
+        super(HelixBeforeEditEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-move.d.ts

@@ -0,0 +1,17 @@
+import type { MoveDetail } from './details.js';
+/**
+ * Cards are about to move, and can be refused.
+ *
+ * **This is the controlled half, the way `helix-before-open` is for a
+ * dialog.** A board moves its own cards by default, writing `x` and `y` onto
+ * each one the way an input writes its own value. A consumer who keeps the
+ * positions in their own state calls `preventDefault()` here, writes what the
+ * detail says into that state, and renders the cards where it puts them.
+ *
+ * Sent for every step of a drag, so a controlled board follows the pointer
+ * rather than jumping on the drop.
+ */
+export declare class HelixBeforeMoveEvent extends CustomEvent<MoveDetail> {
+    static readonly eventName = "helix-before-move";
+    constructor(detail: MoveDetail);
+}

package/dist/events/before-move.js

@@ -0,0 +1,11 @@
+export class HelixBeforeMoveEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-move'; }
+    constructor(detail) {
+        super(HelixBeforeMoveEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-open.d.ts

@@ -0,0 +1,17 @@
+import type { OpenDetail } from './details.js';
+/**
+ * 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 declare class HelixBeforeOpenEvent extends CustomEvent<OpenDetail> {
+    static readonly eventName = "helix-before-open";
+    constructor();
+}

package/dist/events/before-open.js

@@ -0,0 +1,11 @@
+export class HelixBeforeOpenEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-open'; }
+    constructor() {
+        super(HelixBeforeOpenEvent.eventName, {
+            bubbles: false,
+            cancelable: true,
+            composed: false,
+            detail: { open: true },
+        });
+    }
+}

package/dist/events/before-panel-resize.d.ts

@@ -0,0 +1,13 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * 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 declare class HelixBeforePanelResizeEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-panel-resize";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-panel-resize.js

@@ -0,0 +1,11 @@
+export class HelixBeforePanelResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-panel-resize'; }
+    constructor(detail) {
+        super(HelixBeforePanelResizeEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-pin.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeDetail } from './details.js';
+/** A message is about to be pinned or unpinned, and can be refused. */
+export declare class HelixBeforePinEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-pin";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-pin.js

@@ -0,0 +1,11 @@
+export class HelixBeforePinEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-pin'; }
+    constructor(detail) {
+        super(HelixBeforePinEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-reconnect.d.ts

@@ -0,0 +1,14 @@
+import type { ReconnectDetail } from './details.js';
+/**
+ * A connection's end is about to move to another card or another side, and can
+ * be refused.
+ *
+ * **A move, not a request, and that is the difference from `helix-connect`.**
+ * The connection is already an element on the page, so the board rewrites its
+ * ends itself, the way it writes a card's position onto the card; a page that
+ * holds its connections in state refuses this and writes them there.
+ */
+export declare class HelixBeforeReconnectEvent extends CustomEvent<ReconnectDetail> {
+    static readonly eventName = "helix-before-reconnect";
+    constructor(detail: ReconnectDetail);
+}

package/dist/events/before-reconnect.js

@@ -0,0 +1,11 @@
+export class HelixBeforeReconnectEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-reconnect'; }
+    constructor(detail) {
+        super(HelixBeforeReconnectEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-relabel.d.ts

@@ -0,0 +1,15 @@
+import type { RelabelDetail } from './details.js';
+/**
+ * A label the board draws is about to change, and can be refused.
+ *
+ * **The board edits what it draws and asks for what it does not.** A
+ * connection's label and a group's name are drawn by the board from an
+ * attribute, so the board edits them in place and writes the attribute back,
+ * the way it writes a card's position; a page holding them in state refuses
+ * this and writes them there. A card's own content is the page's, which is why
+ * that is `helix-canvas-edit`, a request, rather than this.
+ */
+export declare class HelixBeforeRelabelEvent extends CustomEvent<RelabelDetail> {
+    static readonly eventName = "helix-before-relabel";
+    constructor(detail: RelabelDetail);
+}

package/dist/events/before-relabel.js

@@ -0,0 +1,11 @@
+export class HelixBeforeRelabelEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-relabel'; }
+    constructor(detail) {
+        super(HelixBeforeRelabelEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-resize.d.ts

@@ -0,0 +1,6 @@
+import type { ChangeDetail } from './details.js';
+/** A divider is about to move, and can be refused. */
+export declare class HelixBeforeResizeEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-resize";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-resize.js

@@ -0,0 +1,11 @@
+export class HelixBeforeResizeEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-resize'; }
+    constructor(detail) {
+        super(HelixBeforeResizeEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-split.d.ts

@@ -0,0 +1,12 @@
+import type { ChangeDetail } from './details.js';
+/**
+ * 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 declare class HelixBeforeSplitEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-before-split";
+    constructor(detail: ChangeDetail);
+}

package/dist/events/before-split.js

@@ -0,0 +1,11 @@
+export class HelixBeforeSplitEvent extends CustomEvent {
+    static { this.eventName = 'helix-before-split'; }
+    constructor(detail) {
+        super(HelixBeforeSplitEvent.eventName, {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            detail,
+        });
+    }
+}

package/dist/events/before-toggle.d.ts

@@ -0,0 +1,23 @@
+import type { ToggleDetail } from './details.js';
+/**
+ * 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 declare class HelixBeforeToggleEvent extends CustomEvent<ToggleDetail> {
+    static readonly eventName = "helix-before-toggle";
+    constructor(detail: ToggleDetail);
+}