@fusion.dev/helix-core 0.0.0-dev

package/dist/mixins/mixin-chart-source/mixin-chart-source.js

@@ -0,0 +1,140 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { property } from 'lit/decorators.js';
+import { ChartPointerController } from '../../controllers/chart-pointer-controller/chart-pointer-controller.js';
+import { SourceController } from '../../controllers/source-controller/source-controller.js';
+import { readRows, readSeries } from '../../utils/read-series/read-series.js';
+/**
+ * How many colours the series palette has, and so where it starts over.
+ *
+ * Here rather than in each chart, which is what it was. Four families held the
+ * same `const PALETTE = 24` and the legend held a fifth: when the palette went
+ * from eight to twenty-four, one of them was missed and drew every ninth series
+ * in the first color again while the legend beside it named the ninth. A
+ * number two files have to agree on is a number that will stop agreeing.
+ */
+export const PALETTE = 24;
+/** The palette slot for the nth series, counting from one and wrapping. */
+export const seriesIndex = (depth) => (depth % PALETTE) + 1;
+/**
+ * The half of a chart that is about finding its numbers rather than drawing.
+ *
+ * Four families had written this out separately, and the row that asked for it
+ * set the bar: two copies is a coincidence and three is a pattern. There were
+ * five copies of `for`, four of `label` and three of the caption fallback by the
+ * time the line and donut charts landed, which is why this arrives now and not
+ * when the second chart did.
+ *
+ * **A mixin rather than a controller**, by the rule the tier notes give: it
+ * introduces `for` and `label`, which a consumer writes. `SourceController` is
+ * the other half and stays a controller, because resolving an id and watching
+ * for changes is behavior nobody calls.
+ *
+ * **`Legend` deliberately does not take this.** It reads a table and has no
+ * drawing to title, so `label` would be API it never uses, and a mixin applied
+ * for four fifths of a fit is how a shared thing starts drifting.
+ */
+export const MixinChartSource = (Base) => {
+    class ChartSourceElement extends Base {
+        constructor() {
+            super(...arguments);
+            /** Resolves `for` and re-renders when the table behind it changes. */
+            this.source = new SourceController(this);
+            /**
+             * Which reading a pointer is nearest, for a tooltip to sit on.
+             *
+             * Public for the same reason `series` and `named` are: a protected member
+             * cannot be cast onto across unrelated classes, so it would be invisible to
+             * every chart that needs it. Reading where a pointer is resting is a fair
+             * thing to ask a chart anyway.
+             */
+            this.pointer = new ChartPointerController(this);
+            /**
+             * The id of the table to read.
+             *
+             * Resolved through `getRootNode()`, so a chart inside another component's
+             * shadow root names a table in that root rather than in the document. A
+             * `<table>` or anything built from grid roles, including `helix-table`.
+             *
+             * **In React this arrives as a property and not as an attribute**, the way
+             * `Tooltip.for` does, so it does not reflect and nothing styles on it.
+             */
+            this.for = '';
+            /**
+             * The drawing's name, for a pointer resting on it.
+             *
+             * Absent falls back to the table's own caption, which is usually the right
+             * words and is already written.
+             */
+            this.label = '';
+        }
+        /**
+         * Re-resolves when the chart is pointed at a different table.
+         *
+         * `SourceController` watches whatever it resolved on connect, and nothing
+         * tells it the id changed. `BarChart` had this and `LineChart` and
+         * `DonutChart` did not, which is the kind of difference that survives
+         * precisely because each file looked complete on its own: pointing a bar
+         * chart at a second table worked and pointing a line chart at one left it
+         * drawing the first. Extracting the four found it.
+         */
+        willUpdate(changed) {
+            super.willUpdate(changed);
+            if (changed.has('for')) {
+                this.source.watch();
+            }
+        }
+        /** The columns of the table, one series each, or none if there is no table. */
+        get series() {
+            const element = this.source.element;
+            return element ? readSeries(element) : [];
+        }
+        /**
+         * What to call the drawing, the consumer's word or the table's own.
+         *
+         * The fallback is the reason this is shared rather than copied: a caption is
+         * already written, already the right words, and already the thing a reader
+         * of the table sees. A chart that made the consumer say it twice would be
+         * asking for the second one to drift.
+         */
+        get named() {
+            return this.label || this.source.element?.querySelector('caption')?.textContent?.trim() || '';
+        }
+        /**
+         * Every row of the table, with each cell's text as well as its number.
+         *
+         * This is where a tooltip's content comes from, and it is deliberately not
+         * `series`. A chart draws numbers; a reader resting a pointer on one wants
+         * what the table says, which is `$128k` and not `128000`, and often wants
+         * the column beside it that nothing plotted at all.
+         *
+         * **Not `rows`, and the rename is the whole point of this paragraph.** It
+         * is the source table's rows, and `rows` on a chart is a name a chart
+         * wants for itself: `helix-heatmap` takes `rows="7"` to mean a calendar
+         * week, and declaring that against a base class whose `rows` is a `Row[]`
+         * getter is a type error at best. The same fault `MixinCollection` had,
+         * where a slot counter called `rows` would have shared one field with a
+         * consumer's data property. Name the member for what it holds rather than
+         * for the shortest word available.
+         */
+        get sourceRows() {
+            const element = this.source.element;
+            return element ? readRows(element) : [];
+        }
+        /** How many readings there are, which is what the pointer maps onto. */
+        get readings() {
+            return this.sourceRows.length;
+        }
+    }
+    __decorate([
+        property()
+    ], ChartSourceElement.prototype, "for", void 0);
+    __decorate([
+        property()
+    ], ChartSourceElement.prototype, "label", void 0);
+    return ChartSourceElement;
+};

package/dist/mixins/mixin-collection/index.d.ts

@@ -0,0 +1 @@
+export { type CollectionElement, MixinCollection } from './mixin-collection.js';

package/dist/mixins/mixin-collection/index.js

@@ -0,0 +1 @@
+export { MixinCollection } from './mixin-collection.js';

package/dist/mixins/mixin-collection/mixin-collection.d.ts

@@ -0,0 +1,58 @@
+import { type LitElement, nothing, type TemplateResult } from 'lit';
+type Constructor<T> = new (...args: any[]) => T;
+/**
+ * The API a collection has for the two states that are not its content.
+ */
+export declare class CollectionElement {
+    /** Whether the rows are still on their way. */
+    loading: boolean;
+    /** What is said while they are. */
+    loadingText: string;
+    /** What is said where there are none and none are coming. */
+    emptyText: string;
+    /**
+     * The status line, or nothing where the collection has content to show.
+     *
+     * Rendered by the component wherever its rows would be.
+     */
+    protected renderStatus(hasContent: boolean): TemplateResult | typeof nothing;
+    /** Binds to a rows slot's `slotchange`, and answers `hasRows` from it. */
+    protected countRows(event: Event): void;
+    /**
+     * Whether there is anything to show, as far as anything can tell.
+     *
+     * True until the rows have been counted, which is what keeps a server from
+     * claiming a list is empty.
+     */
+    protected get hasRows(): boolean;
+}
+/**
+ * Grafts the two states a collection has that are not its content.
+ *
+ * **Empty and loading are different answers and a reader can tell them apart.**
+ * "No results" under a spinner is a lie for as long as the request is in
+ * flight, and a blank box is not an answer at all: a reader cannot know whether
+ * a list is empty, still arriving, or broken. Six components each rendered rows
+ * and none of them said either thing, so every consumer wrote their own and
+ * wrote it differently.
+ *
+ * **`aria-busy` on the collection, not on the message.** A reader with a screen
+ * reader is told the region is changing and then told once, politely, what it
+ * settled on: a live region that fires on every intermediate state is a reader
+ * being read a progress bar.
+ *
+ * **The status replaces the rows rather than sitting above them.** A list that
+ * shows "Loading" over the last request's results is a list that lies about
+ * which question it is answering, and this is the point in a component's life
+ * when a consumer is most likely to be looking at stale content.
+ *
+ * Listbox had `empty-text` and nothing else, and Combobox forwarded it. Both
+ * keep the name, so nothing a consumer wrote has moved.
+ *
+ *
+ * **`empty` and `loading` are documented on each of the five families that
+ * apply this, rather than here.** See `MixinField` for why a class-level tag on
+ * a mixin reaches no manifest.
+ */
+export declare const MixinCollection: <T extends Constructor<LitElement>>(Base: T) => Constructor<CollectionElement> & T;
+export {};

package/dist/mixins/mixin-collection/mixin-collection.js

@@ -0,0 +1,154 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html, nothing } from 'lit';
+import { property, state } from 'lit/decorators.js';
+/**
+ * Grafts the two states a collection has that are not its content.
+ *
+ * **Empty and loading are different answers and a reader can tell them apart.**
+ * "No results" under a spinner is a lie for as long as the request is in
+ * flight, and a blank box is not an answer at all: a reader cannot know whether
+ * a list is empty, still arriving, or broken. Six components each rendered rows
+ * and none of them said either thing, so every consumer wrote their own and
+ * wrote it differently.
+ *
+ * **`aria-busy` on the collection, not on the message.** A reader with a screen
+ * reader is told the region is changing and then told once, politely, what it
+ * settled on: a live region that fires on every intermediate state is a reader
+ * being read a progress bar.
+ *
+ * **The status replaces the rows rather than sitting above them.** A list that
+ * shows "Loading" over the last request's results is a list that lies about
+ * which question it is answering, and this is the point in a component's life
+ * when a consumer is most likely to be looking at stale content.
+ *
+ * Listbox had `empty-text` and nothing else, and Combobox forwarded it. Both
+ * keep the name, so nothing a consumer wrote has moved.
+ *
+ *
+ * **`empty` and `loading` are documented on each of the five families that
+ * apply this, rather than here.** See `MixinField` for why a class-level tag on
+ * a mixin reaches no manifest.
+ */
+export const MixinCollection = (Base) => {
+    class Collection extends Base {
+        constructor() {
+            super(...arguments);
+            /**
+             * Whether the rows are still on their way.
+             *
+             * Reflected, because a stylesheet needs it: the rows that are already there
+             * are dimmed rather than removed while a new set arrives, and only CSS can
+             * say that without the component knowing what a row looks like.
+             */
+            this.loading = false;
+            /**
+             * What is said while they are on their way.
+             */
+            this.loadingText = 'Loading';
+            /**
+             * What is said where there are none, and none are coming.
+             */
+            this.emptyText = 'Nothing to show';
+            /**
+             * Whether the rows have been looked at yet.
+             */
+            this.slotCounted = false;
+            /**
+             * How many there were, the last time anyone looked.
+             *
+             * **Not `rows`, and the rename is the whole point of this comment.**
+             * TypeScript's `private` is a compile-time claim and the runtime field is
+             * whatever it is named, so a subclass declaring `@property() rows` for the
+             * data a consumer hands it would share one field with this counter: the
+             * slot count would overwrite the consumer's array on every `updated`, and
+             * `hasRows` would read the array's length as a slot count. Nothing would
+             * throw. `helix-data-table` takes exactly that property, which is what
+             * found this before it happened.
+             */
+            this.slotRows = 0;
+        }
+        /**
+         * Counts what a rows slot was given.
+         *
+         * Emptiness is a fact about light DOM children and the server has none to
+         * count. `slotchange` never fires there, so `counted` is false exactly when
+         * the answer is unknown, and an unknown answer is not "empty": a list that
+         * shipped "Nothing to show" over markup about to have rows in it is the one
+         * thing an empty state must never do. Listbox's spec caught precisely that.
+         */
+        countRows(event) {
+            this.slotCounted = true;
+            this.slotRows = event.target.assignedElements().length;
+        }
+        get hasRows() {
+            return this.slotCounted ? this.slotRows > 0 : true;
+        }
+        /**
+         * Counts the rows slot after every render.
+         *
+         * `slotchange` alone is not enough, and the gap is exactly the case this
+         * mixin exists for: the event fires when an assignment *changes*, and a
+         * collection that arrives with nothing in it has no change to report. So a
+         * list that was empty from the start never learned it was empty and said
+         * nothing at all, which is the blank box a reader cannot tell from a broken
+         * one. Measured on Table, whose rows slot starts empty.
+         *
+         * The default slot, by name, because that is where every collection in this
+         * library puts its rows: Listbox its options, Tree its items, Table its
+         * rows, Menu and Drilldown their pages. A named slot is a header or a
+         * footer, and neither is content.
+         *
+         * `updated` never runs on the server, which is what keeps `counted` false
+         * exactly when the answer is unknown.
+         */
+        updated(changed) {
+            super.updated?.(changed);
+            const slot = this.renderRoot?.querySelector?.('slot:not([name])');
+            if (!slot) {
+                return;
+            }
+            const rows = slot.assignedElements().length;
+            this.slotCounted = true;
+            if (rows !== this.slotRows) {
+                this.slotRows = rows;
+            }
+        }
+        /**
+         * The status line, or nothing where there is content to show.
+         *
+         * Loading wins over empty. A collection that has not answered yet is not
+         * empty, and saying so is the most common version of this fault: the reader
+         * is told there is nothing a moment before there is something.
+         */
+        renderStatus(hasContent) {
+            if (this.loading) {
+                return html `<p part="loading" role="status">${this.loadingText}</p>`;
+            }
+            if (hasContent) {
+                return nothing;
+            }
+            return html `<p part="empty">${this.emptyText}</p>`;
+        }
+    }
+    __decorate([
+        property({ reflect: true, type: Boolean })
+    ], Collection.prototype, "loading", void 0);
+    __decorate([
+        property({ attribute: 'loading-text' })
+    ], Collection.prototype, "loadingText", void 0);
+    __decorate([
+        property({ attribute: 'empty-text' })
+    ], Collection.prototype, "emptyText", void 0);
+    __decorate([
+        state()
+    ], Collection.prototype, "slotCounted", void 0);
+    __decorate([
+        state()
+    ], Collection.prototype, "slotRows", void 0);
+    return Collection;
+};

package/dist/mixins/mixin-controller-active/mixin-controller-active.d.ts

@@ -0,0 +1,53 @@
+import type { HelixElement } from '../../helix-element/helix-element.js';
+import { type ActivatableItem } from '../../utils/resolve-active-item/resolve-active-item.js';
+type Constructor<T> = new (...args: any[]) => T;
+/**
+ * The public surface `MixinControllerActive` adds.
+ *
+ * Declared separately because TypeScript cannot emit declarations for an
+ * anonymous class that has private members (TS4094).
+ */
+export declare class MixinControllerActiveInterface {
+    /**
+     * Which item is current, by its `value`.
+     *
+     * Reading gives the real one, in either mode. Writing hands ownership to the
+     * consumer: from then on the set announces changes and applies none of them.
+     */
+    active: string;
+    /** Initial item for uncontrolled use. Ignored once `active` is written. */
+    defaultActive: string;
+    /** Requests a new current item, and reports whether the request stood. */
+    requestActive(next: string): boolean;
+    /**
+     * Which item is current, given what there is to choose from.
+     *
+     * The first enabled one when `value` names nothing, which is a set before its
+     * consumer has chosen and a set whose current item has just been removed.
+     */
+    protected resolveActive<Item extends ActivatableItem>(items: Item[]): Item | undefined;
+}
+/**
+ * Grafts "which one of these is the current one" onto a container.
+ *
+ * For a set where one member is current and the set is not a form control:
+ * tabs, a tree, a nav bar, a carousel. Where it *is* a form control the value
+ * is submitted and belongs to `MixinControllerValue`, which is why these are
+ * two mixins and not one with a flag.
+ *
+ * **Announcing before applying is the part worth sharing.** `Tabs` and `Tree`
+ * both wrote the current value straight from the item's event, so a consumer
+ * had no way to refuse a change, while `Radio.Group` announced first. Neither
+ * was wrong on its own and the two together are: whether a selection can be
+ * refused should not depend on which component a reader is looking at.
+ *
+ * **The fallback is the other half.** Four components had written
+ * `items.find(match) ?? items[0]`, and it is not the obvious line it looks
+ * like: it is what makes a set with a `value` naming nothing still show
+ * something, which is every set before its consumer has set one and every set
+ * whose current item has just been removed. `resolveActive` also skips disabled
+ * items, which the hand-written copies did not, so a set opening on a disabled
+ * first item showed it as current.
+ */
+export declare const MixinControllerActive: <T extends Constructor<HelixElement>>(Base: T) => Constructor<MixinControllerActiveInterface> & T;
+export {};

package/dist/mixins/mixin-controller-active/mixin-controller-active.js

@@ -0,0 +1,155 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { property } from 'lit/decorators.js';
+import { HelixActivateEvent, HelixBeforeActivateEvent } from '../../events/events.js';
+import { requestChange } from '../../utils/request-change/request-change.js';
+import { resolveActiveItem, } from '../../utils/resolve-active-item/resolve-active-item.js';
+/**
+ * Grafts "which one of these is the current one" onto a container.
+ *
+ * For a set where one member is current and the set is not a form control:
+ * tabs, a tree, a nav bar, a carousel. Where it *is* a form control the value
+ * is submitted and belongs to `MixinControllerValue`, which is why these are
+ * two mixins and not one with a flag.
+ *
+ * **Announcing before applying is the part worth sharing.** `Tabs` and `Tree`
+ * both wrote the current value straight from the item's event, so a consumer
+ * had no way to refuse a change, while `Radio.Group` announced first. Neither
+ * was wrong on its own and the two together are: whether a selection can be
+ * refused should not depend on which component a reader is looking at.
+ *
+ * **The fallback is the other half.** Four components had written
+ * `items.find(match) ?? items[0]`, and it is not the obvious line it looks
+ * like: it is what makes a set with a `value` naming nothing still show
+ * something, which is every set before its consumer has set one and every set
+ * whose current item has just been removed. `resolveActive` also skips disabled
+ * items, which the hand-written copies did not, so a set opening on a disabled
+ * first item showed it as current.
+ */
+export const MixinControllerActive = (Base) => {
+    // JSDoc is duplicated from the interface deliberately. The interface is what
+    // TypeScript consumers see; this class is what the manifest analyzer reads
+    // when resolving inherited members into dependent packages.
+    class ActiveElement extends Base {
+        constructor() {
+            super(...arguments);
+            /**
+             * Initial item for uncontrolled use.
+             *
+             * Ignored once `active` is written.
+             */
+            this.defaultActive = '';
+            /**
+             * The state, whoever set it, and `undefined` until somebody has.
+             *
+             * One field and not two. Writing always applies, the way a native control
+             * does when a script assigns to it. What the write does not do is change
+             * which mode the element is in.
+             */
+            this.activeState = undefined;
+        }
+        /**
+         * Which item is current, by its `value`.
+         *
+         * Called `active`, which is what this mixin is named for and what it was
+         * not: it declared `value`, so the one mixin whose whole subject is which
+         * item is active had no such property, and `active` meant something else
+         * entirely elsewhere in the library. It still does, and only there now:
+         * `option.active` is the option the keyboard is on, which is a different
+         * question from which one is chosen.
+         *
+         * An accessor pair, the same shape as the other three. Reading gives the
+         * real item; writing hands ownership to the consumer, so `<helix-tabs
+         * active="one">` is a set that stays on that tab and `default-active` is
+         * how markup says where to start.
+         *
+         *
+         */
+        get active() {
+            return this.activeState ?? this.defaultActive;
+        }
+        set active(next) {
+            const previous = this.active;
+            this.activeState = next;
+            this.requestUpdate('active', previous);
+        }
+        /**
+         * Requests a new current item, and reports whether the request stood.
+         *
+         * Announces before it acts, so `preventDefault()` on the `helix-before-activate` is
+         * a refusal and nothing moves. Unlike a native control, nothing has moved
+         * by the time this runs, so refusing is simply not writing: there is
+         * nothing to put back. Nobody refusing means the set updates itself,
+         * whether or not a consumer declared `active`, a declared property being a
+         * seed and a correction. See 294.
+         */
+        requestActive(next) {
+            if (next === this.active) {
+                return true;
+            }
+            const applied = requestChange({
+                apply: (value) => {
+                    const previous = this.active;
+                    this.activeState = value;
+                    this.requestUpdate('active', previous);
+                },
+                event: (value) => new HelixBeforeActivateEvent({ value }),
+                host: this,
+                next,
+            });
+            if (applied) {
+                this.announceActivated(next);
+            }
+            return applied;
+        }
+        /**
+         * Says the current child moved, once it has.
+         *
+         * **This was the only one of the four mixins with no notification**, and the
+         * event class said so deliberately: no native word means "a set chose a
+         * different member", so borrowing `change` would be a lie about what moved.
+         * That half still holds, and is why the pair is `helix-activate`. What did
+         * not follow is that a set should therefore announce nothing.
+         *
+         * The cost is the one 294 fixed for values and left here. A consumer who
+         * only wants to know which child is current had one channel and it fires
+         * *before* `apply`, so `currentTarget.active` is the previous value inside
+         * the handler and `detail.value` is a proposal another listener may refuse.
+         * Measured across the four families taking this: `Tabs` and `Tree` looked
+         * covered because `helix-select` bubbles up from a child, which fires when an
+         * item is *chosen* and not when `active` is assigned, and `Steps` and
+         * `Video Playlist` announced nothing at all.
+         *
+         * **After `apply`, which is the whole reason it is a second event**, so the
+         * state is on the element by the time a handler reads it. Not cancelable:
+         * the decision was taken by the event before this one, and two refusable
+         * events for one transition are two answers to one question. See #325.
+         */
+        announceActivated(value) {
+            this.dispatchEvent(new HelixActivateEvent({ value }));
+        }
+        /**
+         * Which item is current, given what there is to choose from.
+         *
+         * The first enabled one when `value` names nothing, which is a set before
+         * its consumer has chosen and a set whose current item has just been
+         * removed. Disabled items are skipped in the fallback but not in the match:
+         * a consumer who names a disabled item meant it, and quietly moving to
+         * another would be the component overruling them.
+         */
+        resolveActive(items) {
+            return resolveActiveItem(this.active, items);
+        }
+    }
+    __decorate([
+        property()
+    ], ActiveElement.prototype, "active", null);
+    __decorate([
+        property({ attribute: 'default-active' })
+    ], ActiveElement.prototype, "defaultActive", void 0);
+    return ActiveElement;
+};

package/dist/mixins/mixin-controller-checked/mixin-controller-checked.d.ts

@@ -0,0 +1,54 @@
+import type { HelixElement } from '../../helix-element/helix-element.js';
+type Constructor<T> = new (...args: any[]) => T;
+/**
+ * The public surface `MixinControllerChecked` adds.
+ *
+ * Declared separately because TypeScript cannot emit declarations for an
+ * anonymous class that has private members (TS4094). Casting the mixin's return
+ * to this interface keeps the internals private and the build working.
+ */
+export declare class MixinControllerCheckedInterface {
+    /**
+     * Whether the control is checked.
+     *
+     * Reading gives the real state, in either mode. Writing hands ownership to
+     * the consumer: from then on the control announces changes and applies none
+     * of them.
+     */
+    checked: boolean;
+    /** Initial checked state for uncontrolled use. Ignored once `checked` is set. */
+    defaultChecked: boolean;
+    /**
+     * Requests a checked change, and reports whether it was applied.
+     *
+     * Announces before it acts: a listener calling `preventDefault()` on the
+     * `helix-before-toggle` refuses the change, and nothing moves.
+     */
+    requestChecked(next: boolean): boolean;
+    /** Requests the opposite of the current state. */
+    toggleChecked(): boolean;
+    /**
+     * Drops the uncontrolled state, so the control reads `defaultChecked` again.
+     *
+     * A form reset has to return a control to what its markup declared. Clearing
+     * `checked` alone cannot do it: that only leaves controlled mode, and the
+     * uncontrolled value the element has been keeping is private to the mixin
+     * and would still be what `checked` reports.
+     */
+    resetChecked(): void;
+}
+/**
+ * Grafts controlled and uncontrolled checked state onto a base class.
+ *
+ * Which mode it is in is read once, at the first update, from whether anything
+ * had set `checked` by then: markup, a hydrating server's attributes and a
+ * framework's initial properties have all arrived, and nothing else has
+ * happened yet. Set, and the consumer owns it and the element only announces.
+ * Unset, and the element owns it and `defaultChecked` says where it starts.
+ *
+ * Records `:state(checked)` whenever the element is checked, in either mode.
+ * Styled tiers select on that rather than on `[checked]`, which is absent for
+ * uncontrolled consumers.
+ */
+export declare const MixinControllerChecked: <T extends Constructor<HelixElement>>(Base: T) => Constructor<MixinControllerCheckedInterface> & T;
+export {};