@fusion.dev/helix-core 0.143.0 → 0.145.0

package/dist/controllers/aria-forward-controller/aria-forward-controller.d.ts

@@ -31,6 +31,14 @@ export interface AriaForwardOptions {
     named?: () => boolean;
     /** The focusable thing in the shadow root, or null before it renders. */
     target: () => HTMLElement | null;
+    /**
+     * How to name the control, said in a warning when it has no accessible
+     * name once it has rendered. Absent, the name is not checked.
+     *
+     * For a control named by its content or a host attribute, as a button is. A
+     * field is checked by `MixinField`, which knows its label.
+     */
+    unnamed?: string;
 }
 /**
  * Carries a host's ARIA references down to the control inside it.
@@ -93,6 +101,8 @@ export declare class AriaForwardController implements ReactiveController {
     private readonly named;
     /** What is read after the host's names. See the option. */
     private readonly after;
+    /** How to name the control, where its name is checked. See the option. */
+    private readonly unnamed;
     constructor(host: ReactiveControllerHost & HTMLElement, options: AriaForwardOptions);
     /**
      * Whether the control has a name that did not come from this controller: an

package/dist/controllers/aria-forward-controller/aria-forward-controller.js

@@ -1,3 +1,4 @@
+import { auditName } from '../../utils/audit-name/audit-name.js';
 import { elementById } from '../../utils/element-by-id/element-by-id.js';
 const shownText = (node) => {
     if (node instanceof HTMLSlotElement) {
@@ -16,6 +17,7 @@ const RELATIONSHIPS = [
     ['aria-labelledby', 'ariaLabelledByElements'],
 ];
 const STATES = [
+    'aria-current',
     'aria-expanded',
     'aria-haspopup',
     'aria-controls',
@@ -36,6 +38,7 @@ export class AriaForwardController {
         this.asked = options.label ?? false;
         this.named = options.named;
         this.after = options.labelledByAfter;
+        this.unnamed = options.unnamed;
         host.addController(this);
     }
     namedByItself(target) {
@@ -120,5 +123,8 @@ export class AriaForwardController {
     }
     hostUpdated() {
         this.forward();
+        if (this.unnamed !== undefined) {
+            auditName(this.host, this.target, this.unnamed);
+        }
     }
 }

package/dist/controllers/chart-pointer-controller/chart-pointer-controller.d.ts

@@ -1,4 +1,19 @@
 import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/**
+ * The id every chart puts on its plot, and the boundary a bubble is kept inside.
+ *
+ * **A name six templates and two files have to agree on is a name that will
+ * stop agreeing**, which is `PALETTE`'s argument and it holds harder here: the
+ * failure is silent. `within` resolves by id, so a plot renamed on one side
+ * returns null, the boundary falls back to the viewport, and the bubble goes
+ * back to hanging past the drawing with nothing reported anywhere. The plot is
+ * also what takes focus, and this controller finds it by the same id.
+ *
+ * Fixed rather than generated: it is scoped to one chart's shadow root, where
+ * it is the only one. Declared here, beside the keys that read it, and
+ * re-exported from `drawTooltip`'s module, where it was first declared.
+ */
+export declare const CHART_PLOT = "helix-chart-plot";
 /** What the controller needs of its host, which is a Lit element and a count. */
 export interface ChartPointerHost extends ReactiveControllerHost, HTMLElement {
     /**
@@ -9,6 +24,16 @@ export interface ChartPointerHost extends ReactiveControllerHost, HTMLElement {
      * Where the chart drew itself, which is where the plot is looked for.
      */
     readonly renderRoot: DocumentFragment | HTMLElement;
+    /**
+     * The positions of the cells in a row that hold numbers, which the series
+     * keys move through. Absent, a reading is one series.
+     */
+    readonly plottedColumns?: number[];
+    /**
+     * The palette slot for a cell, or `undefined` for a column no series was
+     * drawn from, such as a scatter's measure across.
+     */
+    seriesOf?(cell: number): number | undefined;
 }
 /**
  * Which reading a pointer is nearest, for a chart that draws no markers.
@@ -33,6 +58,21 @@ export interface ChartPointerHost extends ReactiveControllerHost, HTMLElement {
  * lifts. The table underneath is the readable version and is what a phone
  * should be given, so this listens for `pointermove` and ignores anything whose
  * `pointerType` is not fine.
+ *
+ * **The keyboard moves the same reading, which is what makes it the reading
+ * and not the pointer's.** A chart's plot takes focus (`tabindex="0"` on the
+ * element carrying `CHART_PLOT`), and while it has it the arrow keys walk the
+ * readings, Home and End go to the first and the last, and the other pair of
+ * arrows walks the series within a reading. Escape puts the bubble away, as it
+ * does a tooltip. The tooltip follows because it already follows `at`, and the
+ * chart's readout, a polite live region `drawTooltip` renders, says the
+ * reading in words. It speaks only for a key: a pointer crossing a chart is a
+ * sighted reader looking, and a region speaking on every slot it crossed would
+ * talk over everything else on the page.
+ *
+ * No peer charting library ships this, which is the reason it is spelled out
+ * rather than assumed: the table beside the chart has every number, and this
+ * is for a reader who wants the picture's own order, a reading at a time.
  */
 export declare class ChartPointerController implements ReactiveController {
     private host;
@@ -40,6 +80,22 @@ export declare class ChartPointerController implements ReactiveController {
     private plot;
     /** The reading under the pointer, or -1 when the pointer is elsewhere. */
     at: number;
+    /**
+     * How many readings stand in one column of the drawing, for a chart laid out
+     * as a grid.
+     *
+     * `1` is a row of readings, which is every chart but a heatmap. A heatmap's
+     * calendar week stands seven days to a column, so the up and down arrows move
+     * a day and the across pair moves a week, which is where the eye goes.
+     */
+    grid: number;
+    /** Whether the reading was last moved by a key, which is when the readout speaks. */
+    keyed: boolean;
+    /**
+     * The series the keyboard is reading within a reading, as its place among
+     * the plotted columns, or -1 while the whole reading is read.
+     */
+    series: number;
     /**
      * Which axis the readings are laid out along.
      *
@@ -60,6 +116,17 @@ export declare class ChartPointerController implements ReactiveController {
     constructor(host: ChartPointerHost);
     hostConnected(): void;
     hostDisconnected(): void;
+    /**
+     * The cell of the reading the series keys rest on, by its place in the row,
+     * or `undefined` while the whole reading is read.
+     *
+     * The tooltip marks this cell and the readout says it alone. A place in the
+     * row and not a series depth, because a row holds columns nothing was drawn
+     * from, and the bubble lists every one of them.
+     */
+    get column(): number | undefined;
+    /** The cells a series key can rest on: every column a series was drawn from. */
+    private columns;
     /**
      * Tells the tooltip its anchor moved, which nothing else would.
      *
@@ -122,6 +189,28 @@ export declare class ChartPointerController implements ReactiveController {
     accepts(event: Event): boolean;
     /** Puts the pointer on a reading, for a chart that resolves it some other way. */
     set(at: number): void;
+    /**
+     * Whether an event came from the plot itself, which is the one element in
+     * the chart the keys are for.
+     *
+     * By the id every chart gives its plot, asked of the first node on the
+     * event's path: a key pressed in a donut's middle, which a consumer can fill
+     * with a link, is that link's and not the chart's.
+     */
+    private fromPlot;
+    /** Puts the reading away, as Escape and leaving the plot both do. */
+    private clear;
+    private readonly key;
+    /**
+     * Shows the first reading when the plot is reached from the keyboard, so the
+     * bubble and the readout say where the reader has arrived.
+     *
+     * A pointer pressing the plot focuses it too, and is left alone: the
+     * pointer is already showing a reading, and `:focus-visible` is how the
+     * platform says which of the two arrived.
+     */
+    private readonly arrive;
+    private readonly depart;
     private readonly move;
     private readonly leave;
 }

package/dist/controllers/chart-pointer-controller/chart-pointer-controller.js

@@ -1,9 +1,74 @@
 import { isRtl } from '../../utils/is-rtl/is-rtl.js';
+import { stepReading } from './reading-step.js';
+export const CHART_PLOT = 'helix-chart-plot';
 export class ChartPointerController {
     constructor(host) {
         this.moved = false;
         this.at = -1;
+        this.grid = 1;
+        this.keyed = false;
+        this.series = -1;
         this.axis = 'inline';
+        this.key = (event) => {
+            if (!this.fromPlot(event) || event.altKey || event.ctrlKey || event.metaKey) {
+                return;
+            }
+            const count = this.host.readings;
+            if (count === 0) {
+                return;
+            }
+            if (event.key === 'Escape') {
+                if (this.at >= 0) {
+                    event.preventDefault();
+                    this.clear();
+                }
+                return;
+            }
+            const next = stepReading(event.key, { at: this.at, series: this.series }, {
+                axis: this.axis,
+                count,
+                grid: this.grid,
+                rtl: isRtl(this.host),
+                series: this.columns().length,
+            });
+            if (next === undefined) {
+                return;
+            }
+            const { at, series } = next;
+            event.preventDefault();
+            if (at === this.at && series === this.series && this.keyed) {
+                return;
+            }
+            this.at = at;
+            this.series = series;
+            this.keyed = true;
+            this.moved = true;
+            this.host.requestUpdate();
+        };
+        this.arrive = (event) => {
+            if (!this.fromPlot(event) || this.at >= 0) {
+                return;
+            }
+            const plot = event.composedPath()[0];
+            let visible = true;
+            try {
+                visible = plot.matches(':focus-visible');
+            }
+            catch {
+            }
+            if (!visible || this.host.readings === 0) {
+                return;
+            }
+            this.at = 0;
+            this.keyed = true;
+            this.moved = true;
+            this.host.requestUpdate();
+        };
+        this.depart = (event) => {
+            if (this.fromPlot(event) && this.keyed) {
+                this.clear();
+            }
+        };
         this.move = (event) => {
             if (this.axis === 'none' || !this.accepts(event)) {
                 return;
@@ -23,12 +88,14 @@ export class ChartPointerController {
             const next = Math.min(Math.max(slot, 0), count - 1);
             if (next !== this.at) {
                 this.at = next;
+                this.keyed = false;
+                this.series = -1;
                 this.moved = true;
                 this.host.requestUpdate();
             }
         };
         this.leave = () => {
-            if (this.at !== -1) {
+            if (this.at !== -1 && !this.keyed) {
                 this.at = -1;
                 this.host.requestUpdate();
             }
@@ -39,11 +106,29 @@ export class ChartPointerController {
     hostConnected() {
         this.host.addEventListener('pointermove', this.move);
         this.host.addEventListener('pointerleave', this.leave);
+        this.host.addEventListener('keydown', this.key);
+        this.host.addEventListener('focusin', this.arrive);
+        this.host.addEventListener('focusout', this.depart);
     }
     hostDisconnected() {
         this.host.removeEventListener('pointermove', this.move);
         this.host.removeEventListener('pointerleave', this.leave);
+        this.host.removeEventListener('keydown', this.key);
+        this.host.removeEventListener('focusin', this.arrive);
+        this.host.removeEventListener('focusout', this.depart);
         this.at = -1;
+        this.series = -1;
+        this.keyed = false;
+    }
+    get column() {
+        return this.series < 0 ? undefined : this.columns()[this.series];
+    }
+    columns() {
+        const host = this.host;
+        const all = host.plottedColumns ?? [];
+        return host.seriesOf === undefined
+            ? all
+            : all.filter((one) => host.seriesOf?.(one) !== undefined);
     }
     hostUpdated() {
         if (!this.moved) {
@@ -70,8 +155,24 @@ export class ChartPointerController {
     set(at) {
         if (at !== this.at) {
             this.at = at;
+            this.keyed = false;
             this.moved = true;
             this.host.requestUpdate();
         }
     }
+    fromPlot(event) {
+        const target = event.composedPath()[0];
+        return (target instanceof Element &&
+            target.id === CHART_PLOT &&
+            target.getRootNode() === this.host.renderRoot);
+    }
+    clear() {
+        const was = this.at;
+        this.at = -1;
+        this.series = -1;
+        this.keyed = false;
+        if (was !== -1) {
+            this.host.requestUpdate();
+        }
+    }
 }

package/dist/controllers/chart-pointer-controller/reading-step.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Where a key moves the reading of a chart, as arithmetic with no element in
+ * it.
+ *
+ * `ChartPointerController` hears the key and asks this where it goes, so the
+ * map of keys to readings is one function every chart shares, and a spec can
+ * hold it without a page.
+ */
+/** How the readings of a chart are laid out, which decides what each arrow does. */
+export interface ReadingLayout {
+    /**
+     * The axis the readings run along: `inline` along the line of text, `block`
+     * down the box, as a horizontal bar chart runs its categories, and `none`
+     * for a ring or a plane, whose readings are walked in the table's order.
+     */
+    axis: 'block' | 'inline' | 'none';
+    /** How many readings there are. */
+    count: number;
+    /** How many readings stand in one column, for a grid. `1` is a row of them. */
+    grid: number;
+    /** Whether the line of text runs right to left, which turns the inline arrows. */
+    rtl: boolean;
+    /** How many series a reading holds, which the cross pair of arrows walks. */
+    series: number;
+}
+/** A reading and the series within it, `-1` for none and for the whole reading. */
+export interface ReadingPlace {
+    /** The reading, or `-1` for none. */
+    at: number;
+    /** The series within it, by its place among the plotted ones, or `-1` for all of them. */
+    series: number;
+}
+/**
+ * Which way a key moves along the readings: `1`, `-1`, or `0` for a key that
+ * moves something else.
+ *
+ * The arrows along the line on an inline chart, down the box on a block one,
+ * and a whole column across on a grid. The cross pair walks the readings too
+ * wherever a reading holds one series, so no arrow is dead.
+ */
+export declare const alongReadings: (key: string, layout: ReadingLayout) => number;
+/**
+ * Which way a key moves among the series of a reading: the pair of arrows
+ * that does not walk the readings, and only where a reading holds two or more.
+ * Down the bubble's list for the arrow pointing down, or along the line.
+ */
+export declare const amongSeries: (key: string, layout: ReadingLayout) => number;
+/**
+ * Where a key moves the reading, or `undefined` for a key that moves nothing,
+ * which the page keeps.
+ *
+ * Home and End go to the first and the last. From no reading, an arrow moving
+ * on starts at the first and one moving back at the last, so either arrow
+ * starts somewhere a reader expects. A series key on no reading starts on the
+ * first. Nothing walks off either end.
+ */
+export declare const stepReading: (key: string, from: ReadingPlace, layout: ReadingLayout) => ReadingPlace | undefined;

package/dist/controllers/chart-pointer-controller/reading-step.js

@@ -0,0 +1,45 @@
+const vertical = (key) => (key === 'ArrowDown' ? 1 : key === 'ArrowUp' ? -1 : 0);
+const inline = (key, rtl) => key === 'ArrowRight' ? (rtl ? -1 : 1) : key === 'ArrowLeft' ? (rtl ? 1 : -1) : 0;
+export const alongReadings = (key, layout) => {
+    const single = layout.grid > 1 || layout.series < 2;
+    if (layout.axis === 'block') {
+        const down = vertical(key);
+        return down !== 0 || !single ? down : inline(key, layout.rtl);
+    }
+    const across = inline(key, layout.rtl);
+    if (across !== 0) {
+        return across * Math.max(1, layout.grid);
+    }
+    return single ? vertical(key) : 0;
+};
+export const amongSeries = (key, layout) => {
+    if (layout.grid > 1 || layout.series < 2) {
+        return 0;
+    }
+    return layout.axis === 'block' ? inline(key, layout.rtl) : vertical(key);
+};
+export const stepReading = (key, from, layout) => {
+    const last = layout.count - 1;
+    if (last < 0) {
+        return undefined;
+    }
+    if (key === 'Home') {
+        return { at: 0, series: from.series };
+    }
+    if (key === 'End') {
+        return { at: last, series: from.series };
+    }
+    const along = alongReadings(key, layout);
+    if (along !== 0) {
+        const at = from.at < 0 ? (along > 0 ? 0 : last) : Math.min(Math.max(from.at + along, 0), last);
+        return { at, series: from.series };
+    }
+    const among = amongSeries(key, layout);
+    if (among !== 0) {
+        return {
+            at: Math.max(from.at, 0),
+            series: Math.min(Math.max(from.series + among, -1), layout.series - 1),
+        };
+    }
+    return undefined;
+};

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

@@ -24,10 +24,10 @@ export interface CopyOptions {
  * in more places than it looks and a control that does nothing is
  * indistinguishable from a broken one. See `write` above.
  *
- * **Where neither route is allowed, the failure is silence.** The confirmation
- * does not appear, which is the honest report: a message about a clipboard is
- * worse than a chip that did not flash, and there is nothing a reader could do
- * about a permission policy anyway.
+ * **Where neither route is allowed, the copy has failed**, and `failed` holds
+ * for the moment a confirmation would. A component decides whether to say so:
+ * `CopyButton` names itself with its `error-label`, where Color's chip does
+ * not flash at all.
  *
  * **The event is announced after the write, not before it.** It is not
  * cancelable for the same reason: by the time anything could be said, the text
@@ -42,15 +42,20 @@ export declare class CopyController implements ReactiveController {
     private readonly options;
     /** Whether the last write succeeded and is still being confirmed. */
     copied: boolean;
+    /** Whether the last copy put nothing on the clipboard, and is still being said. */
+    failed: boolean;
     private timer;
     constructor(host: ReactiveControllerHost & EventTarget, options?: CopyOptions);
     /**
      * Writes to the clipboard, and confirms it if the platform allowed it.
+     * Resolves to whether the text is on the clipboard.
      *
      * Empty text is not copied. An empty clipboard is not a thing a reader ever
-     * asks for, and confirming one is worse than doing nothing.
+     * asks for, and confirming one is worse than doing nothing. Empty text and a
+     * refused write each hold `failed` for the same moment a copy holds
+     * `copied`, for a component that says so.
      */
-    copy(text: string): Promise<void>;
+    copy(text: string): Promise<boolean>;
     hostDisconnected(): void;
     private reset;
 }

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

@@ -34,30 +34,32 @@ export class CopyController {
         this.host = host;
         this.options = options;
         this.copied = false;
+        this.failed = false;
         host.addController(this);
     }
     async copy(text) {
-        if (text === '') {
-            return;
-        }
-        if (!(await write(text))) {
-            return;
-        }
+        const wrote = text !== '' && (await write(text));
         if (this.host instanceof HTMLElement && !this.host.isConnected) {
-            return;
+            return wrote;
         }
-        this.copied = true;
+        this.copied = wrote;
+        this.failed = !wrote;
         this.host.requestUpdate();
-        this.host.dispatchEvent(new HelixCopyEvent({ value: text }));
+        if (wrote) {
+            this.host.dispatchEvent(new HelixCopyEvent({ value: text }));
+        }
         this.reset();
         this.timer = setTimeout(() => {
             this.copied = false;
+            this.failed = false;
             this.host.requestUpdate();
         }, this.options.after ?? 1200);
+        return wrote;
     }
     hostDisconnected() {
         this.reset();
         this.copied = false;
+        this.failed = false;
     }
     reset() {
         if (this.timer !== undefined) {

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

@@ -0,0 +1,55 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** What a `CountdownController` does when its time runs out, and when it stops and starts. */
+export interface CountdownOptions {
+    /** Runs once the time is spent. */
+    done: () => void;
+    /** Runs with `true` when the clock stops partway and `false` when it runs again. */
+    paused?: (paused: boolean) => void;
+}
+/**
+ * A lifetime that pauses: a message that dismisses itself after a time, and
+ * holds that time while a reader is on it.
+ *
+ * Toast's items and Announcement each dismiss themselves after `duration`,
+ * and each stops the clock while the pointer or focus is on the message, so a
+ * reader partway through is not cut off. Resuming continues from what was
+ * left rather than starting over.
+ *
+ * **Holds are counted, not flagged.** Hover and focus stop the same clock and
+ * are independent: a pointer can leave while focus stays. Uncounted, a reader
+ * who tabs into a message and then moves the pointer off it has the clock
+ * restarted underneath them. Only the last one out starts it again.
+ *
+ * **Leaving the page pauses it**, keeping the time already spent, and drops
+ * the holds, since a pointer or focus on a detached element never leaves it.
+ * Coming back does not resume on its own: the host says whether it should,
+ * such as only while it is still showing. `DelayController` is the other wait
+ * in core, for a wait that starts over and forgets itself on leaving.
+ */
+export declare class CountdownController implements ReactiveController {
+    private readonly options;
+    /** When the current run began, or nothing while the clock is stopped. */
+    private startedAt;
+    /** What is left of the time, so resuming continues rather than restarts. */
+    private remaining;
+    private timer;
+    /** How many reasons there are to hold the clock. */
+    private holds;
+    constructor(host: ReactiveControllerHost, options: CountdownOptions);
+    /** Whether the clock is running now. */
+    get running(): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /** Starts the clock at `ms`. Nothing, zero or less starts nothing. */
+    start(ms: number | undefined): void;
+    /** Stops the clock and keeps the time that is left. */
+    pause(): void;
+    /** Runs the clock again from where it stopped. */
+    resume(): void;
+    /** Stops the clock where it is, as a dismissal does. */
+    cancel(): void;
+    /** One more reason to hold the clock, such as a pointer arriving. */
+    hold(): void;
+    /** One reason fewer, and the clock runs again once none is left. */
+    release(): void;
+}

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

@@ -0,0 +1,57 @@
+export class CountdownController {
+    constructor(host, options) {
+        this.options = options;
+        this.holds = 0;
+        host.addController(this);
+    }
+    get running() {
+        return this.timer !== undefined;
+    }
+    hostConnected() { }
+    hostDisconnected() {
+        this.pause();
+        this.holds = 0;
+    }
+    start(ms) {
+        if (ms === undefined || !(ms > 0)) {
+            return;
+        }
+        this.remaining = ms;
+        this.resume();
+    }
+    pause() {
+        if (this.timer === undefined || this.startedAt === undefined) {
+            return;
+        }
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        this.remaining = Math.max((this.remaining ?? 0) - (Date.now() - this.startedAt), 0);
+        this.startedAt = undefined;
+        this.options.paused?.(true);
+    }
+    resume() {
+        if (this.timer !== undefined || this.remaining === undefined || this.remaining <= 0) {
+            return;
+        }
+        this.startedAt = Date.now();
+        this.options.paused?.(false);
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.options.done();
+        }, this.remaining);
+    }
+    cancel() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+    }
+    hold() {
+        this.holds += 1;
+        this.pause();
+    }
+    release() {
+        this.holds = Math.max(this.holds - 1, 0);
+        if (this.holds === 0) {
+            this.resume();
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+import type { ReactiveController, ReactiveControllerHost } from 'lit';
+/** What a `DelayController` is for. */
+export interface DelayOptions {
+    /**
+     * Whether the host renders `elapsed`, and so updates when it moves.
+     * Defaults to `true`; a wait that only runs `done`, a debounce, leaves its
+     * host alone.
+     */
+    renders?: boolean;
+}
+/**
+ * A wait an element starts and restarts: whether it has run out, and what runs
+ * when it does.
+ *
+ * Avatar's `fallback-delay`, Image's `placeholder-delay` and Loader's `delay`
+ * each hold a region back until a wait is over, and Listbox's `filter-delay`
+ * holds a filter back until typing pauses. Each kept a timer, a flag and the
+ * clean-up by hand; this keeps the three together, and clears the timer when
+ * the element leaves the page.
+ *
+ * `elapsed` is what a template reads, and the host updates when it moves,
+ * unless `renders` is false.
+ * Leaving the page stops the wait without forgetting that it ran out, so a
+ * loader moved to another place in the page does not wait again.
+ */
+export declare class DelayController implements ReactiveController {
+    private readonly host;
+    private readonly options;
+    /** Whether the last wait started has run out. */
+    elapsed: boolean;
+    private timer;
+    private done;
+    constructor(host: ReactiveControllerHost, options?: DelayOptions);
+    /** Whether a wait is running. */
+    get pending(): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    /**
+     * Starts the wait over: `elapsed` goes back to false, and after `ms`
+     * milliseconds it turns true and `done` runs. No `ms` starts no wait, which
+     * leaves `elapsed` false.
+     */
+    start(ms?: number, done?: () => void): void;
+    /** Stops a running wait, leaving `elapsed` as it is. */
+    cancel(): void;
+    /** Ends a running wait now, as though it had run out. Nothing happens where none is running. */
+    flush(): void;
+    private finish;
+    private mark;
+}