@fusion.dev/helix-core 0.142.1 → 0.144.0

package/dist/events/events.d.ts

@@ -261,6 +261,34 @@ export declare class HelixCanvasEditEvent extends CustomEvent<{
         name: string;
     });
 }
+/** Why a file field did not take a file. */
+export type Refusal = 'count' | 'invalid' | 'size' | 'type';
+/** One file a file field did not take, and why. */
+export interface RefusedFile {
+    /** The file. */
+    readonly file: File;
+    /** What the field's `validate` said about it, where it was the one refusing. */
+    readonly message?: string;
+    /** Why it was not taken. */
+    readonly reason: Refusal;
+}
+/** The files a file field refused. */
+export interface RejectDetail {
+    /** Each refused file with its reason, in the order they arrived. */
+    files: RefusedFile[];
+}
+/**
+ * Files arrived at a file field and some were refused: by `accept`, by
+ * `max-file-size`, by `max-files`, or by the field's own `validate`.
+ *
+ * A notification and not a request, because the files are already left out;
+ * the event is how a page tells the reader why. Bubbles and is composed, so a
+ * form around the field hears it.
+ */
+export declare class HelixRejectEvent extends CustomEvent<RejectDetail> {
+    static readonly eventName = "helix-reject";
+    constructor(detail: RejectDetail);
+}
 /** What a reader asked to take off the board. */
 export interface RemoveDetail {
     /** The cards, by name. */
@@ -319,6 +347,13 @@ export type MapPanDetail = ViewportPanDetail;
 export type MapZoomDetail = ViewportZoomDetail;
 /** Detail carried by `helix-navigate`. */
 export interface NavigateDetail {
+    /**
+     * The page asked for, as a number, where the component pages by number.
+     *
+     * Beside `value` rather than in place of it, because a calendar pages by
+     * month and its `value` is a month.
+     */
+    page?: number;
     /** Where the view is moving to, in whatever the component pages by. */
     value: string;
 }
@@ -368,7 +403,7 @@ export interface FacetDetail {
 export interface ReadDetail {
     /**
      * The state being asked for, as a boolean rather than a word that reads like
-     * one, which is `helix-toggle`'s rule and for the same reason: `"false"` is
+     * one, which is `helix-before-toggle`'s rule and for the same reason: `"false"` is
      * truthy and a consumer who forgets that marks everything read.
      */
     read: boolean;
@@ -472,7 +507,7 @@ export declare class HelixDismissEvent extends CustomEvent<DismissDetail> {
  *
  * A boolean is the case where it *is* lost, because `"false"` is truthy, so a
  * consumer who forgets to compare against the word gets the opposite answer and
- * no error. That is why checkedness has `helix-toggle` and its own boolean, and
+ * no error. That is why checkedness has `helix-before-toggle` and its own boolean, and
  * it is the line to hold: **stringify a value, never a fact.** A new control
  * whose state is a boolean wants an event with a typed detail, not a `String()`
  * call here.
@@ -750,11 +785,37 @@ export declare class HelixBeforePinEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-before-pin";
     constructor(detail: ChangeDetail);
 }
+/**
+ * A transcript was pinned to the bottom, or let go of it.
+ *
+ * The notification half of `helix-before-pin`, sent once `pinned` has moved,
+ * so `currentTarget.pinned` is the new state and `detail.value` says it as
+ * `true` or `false`. Not cancelable: the decision was the request's.
+ */
+export declare class HelixPinEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-pin";
+    constructor(detail: ChangeDetail);
+}
 /** 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);
 }
+/**
+ * A divider settled somewhere new.
+ *
+ * The notification half of `helix-before-resize`, sent once `position` has
+ * moved, with the new position. Not cancelable: the decision was the
+ * request's.
+ *
+ * **Past tense, because `helix-resize` was already taken** by a measurement,
+ * the height a sandboxed preview reports for what it drew, and one name cannot
+ * carry both.
+ */
+export declare class HelixResizedEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-resized";
+    constructor(detail: ChangeDetail);
+}
 /**
  * The divider between a sandbox's panes is about to move, and can be refused.
  *
@@ -783,6 +844,17 @@ export declare class HelixBeforeCollapseEvent extends CustomEvent<ChangeDetail>
     static readonly eventName = "helix-before-collapse";
     constructor(detail: ChangeDetail);
 }
+/**
+ * A pane shut or reopened.
+ *
+ * The notification half of `helix-before-collapse`, sent once `collapsed` has
+ * moved. `detail.value` is the side that is shut, or empty where both panes
+ * are open. Not cancelable: the decision was the request's.
+ */
+export declare class HelixCollapseEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-collapse";
+    constructor(detail: ChangeDetail);
+}
 /** Source is about to be edited, and can be refused. */
 export declare class HelixBeforeEditEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-before-edit";
@@ -839,11 +911,11 @@ export declare class HelixBeforeToggleEvent extends CustomEvent<ToggleDetail> {
 export interface ScrolledDetail {
     /**
      * Whether the page is scrolled away from the top, as a boolean and not a word
-     * that reads like one. Follows `helix-toggle`'s rule for the same reason.
+     * that reads like one. Follows `helix-before-toggle`'s rule for the same reason.
      */
     scrolled: boolean;
 }
-/** Detail carried by `helix-toggle`. */
+/** Detail carried by `helix-before-toggle`. */
 export interface ToggleDetail {
     /** The state being asked for, as a boolean and not a word that reads like one. */
     checked: boolean;
@@ -993,6 +1065,12 @@ export interface SelectDetail {
      * A flag says it outright.
      */
     alternate?: boolean;
+    /**
+     * The link of a row that is a link, which the browser follows once the event
+     * is done unless it is canceled. A client-side router cancels it and follows
+     * the link itself.
+     */
+    href?: string;
     /** Value of the item the reader chose. */
     value: string;
 }
@@ -1089,6 +1167,20 @@ export declare class HelixSortEvent extends CustomEvent<SortDetail> {
     static readonly eventName = "helix-sort";
     constructor(detail: SortDetail);
 }
+/**
+ * The rows are in a different order.
+ *
+ * The notification after `helix-sort`, sent once `sort` has moved, with the
+ * order now in force. Not cancelable: the decision was the request's.
+ *
+ * **Past tense, because the plain verb is the request.** `helix-sort` was
+ * cancelable before the library had a word for its notification, and
+ * consumers bind it by that name, so the notification takes the one after it.
+ */
+export declare class HelixSortedEvent extends CustomEvent<SortDetail> {
+    static readonly eventName = "helix-sorted";
+    constructor(detail: SortDetail);
+}
 /**
  * Fired when the reader changes which values a field is filtered by.
  *
@@ -1116,6 +1208,17 @@ export declare class HelixFilterEvent extends CustomEvent<FilterDetail> {
     static readonly eventName = "helix-filter";
     constructor(detail: FilterDetail);
 }
+/**
+ * A component is showing a narrower or a wider set.
+ *
+ * The notification after `helix-filter`, sent once the query has moved, with
+ * the query now in force. Not cancelable, and past tense for the reason
+ * `helix-sorted` is.
+ */
+export declare class HelixFilteredEvent extends CustomEvent<FilterDetail> {
+    static readonly eventName = "helix-filtered";
+    constructor(detail: FilterDetail);
+}
 /** What a shortcut reports when its chord is pressed. */
 export interface ShortcutDetail {
     /**
@@ -1149,6 +1252,17 @@ export declare class HelixSelectEvent extends CustomEvent<SelectDetail> {
     static readonly eventName = "helix-select";
     constructor(detail: SelectDetail);
 }
+/**
+ * A set holds a different selection.
+ *
+ * The notification after a `helix-select` that asked to change what is
+ * selected, sent once the selection has moved, with the selection now in
+ * force. Not cancelable, and past tense for the reason `helix-sorted` is.
+ */
+export declare class HelixSelectedEvent extends CustomEvent<SelectDetail> {
+    static readonly eventName = "helix-selected";
+    constructor(detail: SelectDetail);
+}
 /**
  * Fired when the reader asks for the columns in a different order.
  *
@@ -1166,6 +1280,17 @@ export declare class HelixReorderEvent extends CustomEvent<ChangeDetail> {
     static readonly eventName = "helix-reorder";
     constructor(detail: ChangeDetail);
 }
+/**
+ * The columns are in a different order.
+ *
+ * The notification after `helix-reorder`, sent once the order has moved, with
+ * every field in the new one. Not cancelable, and past tense for the reason
+ * `helix-sorted` is.
+ */
+export declare class HelixReorderedEvent extends CustomEvent<ChangeDetail> {
+    static readonly eventName = "helix-reordered";
+    constructor(detail: ChangeDetail);
+}
 /**
  * Fired when a reader reaches the oldest turn a transcript holds, while there are
  * older ones to fetch.
@@ -1214,6 +1339,7 @@ declare const registry: {
     readonly HelixCanvasViewEvent: typeof HelixCanvasViewEvent;
     readonly HelixCanvasZoomEvent: typeof HelixCanvasZoomEvent;
     readonly HelixCaretEvent: typeof HelixCaretEvent;
+    readonly HelixCollapseEvent: typeof HelixCollapseEvent;
     readonly HelixCompleteEvent: typeof HelixCompleteEvent;
     readonly HelixConnectEvent: typeof HelixConnectEvent;
     readonly HelixConsoleEvent: typeof HelixConsoleEvent;
@@ -1222,6 +1348,7 @@ declare const registry: {
     readonly HelixDismissEvent: typeof HelixDismissEvent;
     readonly HelixFacetEvent: typeof HelixFacetEvent;
     readonly HelixFilterEvent: typeof HelixFilterEvent;
+    readonly HelixFilteredEvent: typeof HelixFilteredEvent;
     readonly HelixGraphFilterEvent: typeof HelixGraphFilterEvent;
     readonly HelixGraphLayoutEvent: typeof HelixGraphLayoutEvent;
     readonly HelixGraphPanEvent: typeof HelixGraphPanEvent;
@@ -1240,20 +1367,26 @@ declare const registry: {
     readonly HelixMoveEvent: typeof HelixMoveEvent;
     readonly HelixNavigateEvent: typeof HelixNavigateEvent;
     readonly HelixNextEvent: typeof HelixNextEvent;
+    readonly HelixPinEvent: typeof HelixPinEvent;
     readonly HelixPreviousEvent: typeof HelixPreviousEvent;
     readonly HelixReadEvent: typeof HelixReadEvent;
     readonly HelixReconnectEvent: typeof HelixReconnectEvent;
+    readonly HelixRejectEvent: typeof HelixRejectEvent;
     readonly HelixRelabelEvent: typeof HelixRelabelEvent;
     readonly HelixRemoveEvent: typeof HelixRemoveEvent;
     readonly HelixReorderEvent: typeof HelixReorderEvent;
+    readonly HelixReorderedEvent: typeof HelixReorderedEvent;
+    readonly HelixResizedEvent: typeof HelixResizedEvent;
     readonly HelixResizeEvent: typeof HelixResizeEvent;
     readonly HelixSampleEndEvent: typeof HelixSampleEndEvent;
     readonly HelixSampleStartEvent: typeof HelixSampleStartEvent;
     readonly HelixScrolledEvent: typeof HelixScrolledEvent;
     readonly HelixSelectEvent: typeof HelixSelectEvent;
+    readonly HelixSelectedEvent: typeof HelixSelectedEvent;
     readonly HelixSendEvent: typeof HelixSendEvent;
     readonly HelixShortcutEvent: typeof HelixShortcutEvent;
     readonly HelixSortEvent: typeof HelixSortEvent;
+    readonly HelixSortedEvent: typeof HelixSortedEvent;
     readonly HelixTourAskEvent: typeof HelixTourAskEvent;
 };
 /**

package/dist/events/events.js

@@ -152,6 +152,17 @@ export class HelixCanvasEditEvent extends CustomEvent {
         });
     }
 }
+export class HelixRejectEvent extends CustomEvent {
+    static { this.eventName = 'helix-reject'; }
+    constructor(detail) {
+        super(HelixRejectEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixRemoveEvent extends CustomEvent {
     static { this.eventName = 'helix-remove'; }
     constructor(detail) {
@@ -385,6 +396,17 @@ export class HelixBeforePinEvent extends CustomEvent {
         });
     }
 }
+export class HelixPinEvent extends CustomEvent {
+    static { this.eventName = 'helix-pin'; }
+    constructor(detail) {
+        super(HelixPinEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixBeforeResizeEvent extends CustomEvent {
     static { this.eventName = 'helix-before-resize'; }
     constructor(detail) {
@@ -396,6 +418,17 @@ export class HelixBeforeResizeEvent extends CustomEvent {
         });
     }
 }
+export class HelixResizedEvent extends CustomEvent {
+    static { this.eventName = 'helix-resized'; }
+    constructor(detail) {
+        super(HelixResizedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixBeforeSplitEvent extends CustomEvent {
     static { this.eventName = 'helix-before-split'; }
     constructor(detail) {
@@ -429,6 +462,17 @@ export class HelixBeforeCollapseEvent extends CustomEvent {
         });
     }
 }
+export class HelixCollapseEvent extends CustomEvent {
+    static { this.eventName = 'helix-collapse'; }
+    constructor(detail) {
+        super(HelixCollapseEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixBeforeEditEvent extends CustomEvent {
     static { this.eventName = 'helix-before-edit'; }
     constructor(detail) {
@@ -582,6 +626,17 @@ export class HelixSortEvent extends CustomEvent {
         });
     }
 }
+export class HelixSortedEvent extends CustomEvent {
+    static { this.eventName = 'helix-sorted'; }
+    constructor(detail) {
+        super(HelixSortedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixFacetEvent extends CustomEvent {
     static { this.eventName = 'helix-facet'; }
     constructor(detail) {
@@ -604,6 +659,17 @@ export class HelixFilterEvent extends CustomEvent {
         });
     }
 }
+export class HelixFilteredEvent extends CustomEvent {
+    static { this.eventName = 'helix-filtered'; }
+    constructor(detail) {
+        super(HelixFilteredEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixShortcutEvent extends CustomEvent {
     static { this.eventName = 'helix-shortcut'; }
     constructor(detail) {
@@ -626,6 +692,17 @@ export class HelixSelectEvent extends CustomEvent {
         });
     }
 }
+export class HelixSelectedEvent extends CustomEvent {
+    static { this.eventName = 'helix-selected'; }
+    constructor(detail) {
+        super(HelixSelectedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixReorderEvent extends CustomEvent {
     static { this.eventName = 'helix-reorder'; }
     constructor(detail) {
@@ -637,6 +714,17 @@ export class HelixReorderEvent extends CustomEvent {
         });
     }
 }
+export class HelixReorderedEvent extends CustomEvent {
+    static { this.eventName = 'helix-reordered'; }
+    constructor(detail) {
+        super(HelixReorderedEvent.eventName, {
+            bubbles: true,
+            cancelable: false,
+            composed: true,
+            detail,
+        });
+    }
+}
 export class HelixHistoryEvent extends CustomEvent {
     static { this.eventName = 'helix-history'; }
     constructor() {
@@ -669,6 +757,7 @@ const registry = {
     HelixCanvasViewEvent,
     HelixCanvasZoomEvent,
     HelixCaretEvent,
+    HelixCollapseEvent,
     HelixCompleteEvent,
     HelixConnectEvent,
     HelixConsoleEvent,
@@ -677,6 +766,7 @@ const registry = {
     HelixDismissEvent,
     HelixFacetEvent,
     HelixFilterEvent,
+    HelixFilteredEvent,
     HelixGraphFilterEvent,
     HelixGraphLayoutEvent,
     HelixGraphPanEvent,
@@ -695,20 +785,26 @@ const registry = {
     HelixMoveEvent,
     HelixNavigateEvent,
     HelixNextEvent,
+    HelixPinEvent,
     HelixPreviousEvent,
     HelixReadEvent,
     HelixReconnectEvent,
+    HelixRejectEvent,
     HelixRelabelEvent,
     HelixRemoveEvent,
     HelixReorderEvent,
+    HelixReorderedEvent,
+    HelixResizedEvent,
     HelixResizeEvent,
     HelixSampleEndEvent,
     HelixSampleStartEvent,
     HelixScrolledEvent,
     HelixSelectEvent,
+    HelixSelectedEvent,
     HelixSendEvent,
     HelixShortcutEvent,
     HelixSortEvent,
+    HelixSortedEvent,
     HelixTourAskEvent,
 };
 export const helixEventNames = new Set(Object.values(registry).map((event) => event.eventName));

package/dist/helix-element/react-bridge.js

@@ -78,16 +78,18 @@ export const reactPropFor = (event) => {
     }
     return `on${event.type.charAt(0).toUpperCase()}${event.type.slice(1)}`;
 };
+const lowercasePropFor = (event) => event.type.includes('-') || REACT_WIRES.has(event.type) ? undefined : `on${event.type}`;
 export const bindReactHandler = (host, event) => {
     const props = reactPropsOf(host);
     if (props === undefined) {
         return;
     }
     auditReactProps(host, props);
-    const key = reactPropFor(event);
-    const handler = key === undefined ? undefined : props[key];
-    if (typeof handler === 'function') {
-        host.addEventListener(event.type, handler);
+    for (const key of [reactPropFor(event), lowercasePropFor(event)]) {
+        const handler = key === undefined ? undefined : props[key];
+        if (typeof handler === 'function') {
+            host.addEventListener(event.type, handler);
+        }
     }
 };
 export const applyReactProperties = (host) => {

package/dist/helix-form-element/helix-form-element.d.ts

@@ -11,8 +11,17 @@ import { HelixElement } from '../helix-element/helix-element.js';
  * `internals` comes from `HelixElement`, which attaches it for every component.
  * `attachInternals()` throws on a second call, so only one class attaches it.
  *
- * The class carries only what every form participant needs. `value`, validity,
- * and the reset and restore callbacks are added with the first input component.
+ * The class carries only what every form participant needs. `value` and the
+ * reset and restore callbacks are added with the first input component.
+ *
+ * **The validity API is the platform's, read through `internals`**, so
+ * `checkValidity()`, `reportValidity()` and `setCustomValidity()` work on the
+ * host as they do on a native control. A custom message is laid over whatever
+ * the control itself reports, which is why `setValidity` is wrapped below.
+ *
+ * **Focus goes to the control's first tab stop**, for `focus()` and for a
+ * press on a `<label>` that names the host. A host is not focusable itself, so
+ * without this a label press focused nothing on half the controls.
  *
  * @since 0.1.0
  * @status experimental
@@ -109,6 +118,16 @@ export declare class HelixFormElement extends HelixElement {
      * middle of removing.
      */
     formDisabledCallback(disabled: boolean): void;
+    /**
+     * Whether an ancestor `<fieldset disabled>` holds the control, outside its
+     * first `<legend>`, read from the tree.
+     *
+     * For the one case the callback cannot report: a control disabled itself and
+     * by a fieldset, whose own `disabled` is then removed. The effective state does
+     * not change, so the platform does not call, and the fieldset's hold has to
+     * be read.
+     */
+    private get heldByFieldset();
     /**
      * Called by the browser when the form is reset. It does nothing here, and
      * every override calls it.
@@ -158,6 +177,116 @@ export declare class HelixFormElement extends HelixElement {
      * Here rather than on each control.
      */
     name: string;
+    constructor();
+    /** The platform's own `setValidity`, which the wrapper above calls. */
+    private readonly reportValidityTo;
+    /** What the control last reported, before any custom error is laid over it. */
+    private reported;
+    /** The message `setCustomValidity` was given. */
+    private customValidity;
+    /** The `validityFeedback` the platform was last told about. */
+    private appliedFeedback;
+    /**
+     * @internal A message that marks the control invalid, from a layer above this
+     * one. `MixinField` answers with `feedback`, so a field showing what is wrong
+     * does not submit.
+     */
+    protected get validityFeedback(): string;
+    /**
+     * Hands the platform the control's own verdict with any custom error on top,
+     * anchored where focus can go.
+     */
+    private applyValidity;
+    /**
+     * Where the browser points its bubble: the anchor a control gave if focus
+     * can go there, and its first tab stop otherwise.
+     *
+     * A group anchors on a part that holds its members and cannot take focus,
+     * and the platform then refuses the submission, logs that the control is
+     * not focusable, and leaves the reader on the submit button.
+     */
+    protected validationAnchor(anchor?: HTMLElement): HTMLElement | undefined;
+    /**
+     * Whether the control meets its constraints, and why not.
+     *
+     * @reference https://developer.mozilla.org/docs/Web/API/ElementInternals/validity ElementInternals.validity
+     */
+    get validity(): ValidityState;
+    /** The message the browser would show for the control, or an empty string. */
+    get validationMessage(): string;
+    /** Whether the control is checked when its form is submitted. */
+    get willValidate(): boolean;
+    /**
+     * Returns whether the control is valid, and fires `invalid` on it when it is
+     * not.
+     */
+    checkValidity(): boolean;
+    /**
+     * Returns whether the control is valid, and when it is not, fires `invalid`
+     * and shows the browser's message at the control.
+     */
+    reportValidity(): boolean;
+    /**
+     * Marks the control invalid with `message`, or clears that with an empty
+     * string, as on a native control. The form does not submit while it is set.
+     */
+    setCustomValidity(message: string): void;
+    /**
+     * The element focus goes to: the control's first tab stop, or `null` where
+     * there is none.
+     *
+     * Read through shadow roots and slots, so a group lands on the member that
+     * holds its tab stop, which is the chosen radio in a radio group.
+     */
+    protected get focusTarget(): HTMLElement | null;
+    /** Moves focus to the control, as focusing a native control does. */
+    focus(options?: FocusOptions): void;
+    /**
+     * Focuses the control when its `<label>` is pressed.
+     *
+     * The label sends the host a click of the browser's own after trying to
+     * focus it, and a host that is not focusable takes nothing from that try.
+     * Only a click that starts at the host and that the browser sent: one from
+     * inside has landed where it meant to, and `click()` from a script does not
+     * focus a native control either.
+     */
+    private readonly focusFromLabel;
+    /**
+     * Re-anchors the verdict as the form checks it, because the control's
+     * members may have rendered since it last reported, and the anchor read then
+     * was the best there was.
+     */
+    private readonly refreshAnchor;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * @internal Whether this control is a field that counts against implicit
+     * submission: a single line of text, as `<input type="text">` is.
+     */
+    protected get blocksImplicitSubmission(): boolean;
+    /** @internal Whether this control submits its form, for finding the form's default button. */
+    protected get submitsForm(): boolean;
+    /** @internal Activates the control as its form's default button. */
+    protected activate(): void;
+    /**
+     * Submits the form the way pressing Enter in a native text field does.
+     *
+     * The control's own input is in a shadow root and has no form owner, so the
+     * platform never runs implicit submission for it. This runs it: the form's
+     * default button is activated, the first submit button in it, a Helix one
+     * included. With none, the form is submitted when it holds no more than one
+     * field that counts against implicit submission, and nothing happens
+     * otherwise.
+     *
+     * @reference https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#implicit-submission implicit submission
+     */
+    protected submitImplicitly(): void;
+    /** The form's default button, the first submit button in it, native or Helix. */
+    protected static defaultButton(form: HTMLFormElement): Element | undefined;
+    /** Whether `target` is a native field of `form` that Enter submits it from. */
+    protected static submitsOnEnter(target: EventTarget | undefined, form: HTMLFormElement): boolean;
+    /** Whether `element` is a submit button, native or Helix. */
+    protected static submits(element: Element): boolean;
     /**
      * The form the control belongs to, or `null`.
      *