@expressivecss/expressive 0.15.0 → 0.16.0

package/dist/types/components/navigationRail.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface NavigationRailOptions extends BaseOptions {
     /**
      * Called before the rail expands.
@@ -20,17 +20,19 @@ export interface NavigationRailOptions extends BaseOptions {
 /**
  * Navigation rail. Layout is CSS (collapsed / .expanded). This class
  * toggles that class from the menu button, closes a compact overlay on
- * Escape or a scrim tap, and keeps aria-expanded in sync.
+ * Escape or a scrim tap, and keeps aria-expanded in sync. A destination's
+ * .navigation-rail-panel is a native popover; this class also opens it on
+ * mouse hover.
  */
 export declare class NavigationRail extends Component<NavigationRailOptions> {
     isExpanded: boolean;
     private _toggle;
     private _mql;
+    private _hoverPanel;
+    private _hoverTimer;
     constructor(el: HTMLElement, options: Partial<NavigationRailOptions>);
     static get defaults(): NavigationRailOptions;
-    static init(el: HTMLElement, options?: Partial<NavigationRailOptions>): NavigationRail;
-    static init(els: InitElements<InitElement>, options?: Partial<NavigationRailOptions>): NavigationRail[];
-    static getInstance(el: HTMLElement): NavigationRail;
+    static key: string;
     destroy(): void;
     /**
      * Expands the rail. On compact windows the overlay (scrim) is CSS.
@@ -48,6 +50,15 @@ export declare class NavigationRail extends Component<NavigationRailOptions> {
     private _isCompact;
     private _isModal;
     private _sync;
+    /** The side panel of the enabled destination around `target`, if any. */
+    private _panelAt;
+    private _hoverOpen;
+    private _hoverClose;
+    private _onPointerOver;
+    private _onPointerLeave;
+    private _pinPanel;
     private _onClick;
+    private _escapePanel;
+    private _isScrimClick;
     private _onKeyDown;
 }

package/dist/types/components/particles.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface ParticlesOptions extends BaseOptions {
     /**
      * Number of particles.
@@ -54,14 +54,18 @@ export declare class Particles extends Component<ParticlesOptions> {
     private _last;
     private _mouse;
     private _still;
+    private _visible;
+    private _motion;
+    private _theme;
     private _resizeObserver;
     private _visibility;
     constructor(el: HTMLElement, options: Partial<ParticlesOptions>);
     static get defaults(): ParticlesOptions;
-    static init(el: HTMLElement, options?: Partial<ParticlesOptions>): Particles;
-    static init(els: InitElements<InitElement>, options?: Partial<ParticlesOptions>): Particles[];
-    static getInstance(el: HTMLElement): Particles;
+    static key: string;
     destroy(): void;
+    private _animate;
+    private _onMotion;
+    private _repaint;
     private _start;
     private _stop;
     private _onPointerMove;

package/dist/types/components/pieChart.d.ts

@@ -1,13 +1,16 @@
-import { InitElements, InitElement } from '../core/component';
 import { LineChart, LineChartOptions } from './lineChart';
 export type PieChartOptions = LineChartOptions;
 /**
  * Pie chart. It reads its <table> like LineChart, but draws each row of the
  * first value column as a slice of the whole, clockwise from the top, with
  * a legend of every row and its share. With `.donut`, a <tfoot> row is the
- * total in the middle. Further columns show in the tooltip.
+ * total in the middle. Further columns show in the tooltip. With
+ * `data-other`, rows under that percentage of the whole become one row,
+ * last, named by `data-other-label` ("Other" by default); the table keeps
+ * every row.
  *
- * Re-run `PieChart.init(el)` after changing the table.
+ * Call `update()` after changing the table, or start it with `watch` or
+ * `data-watch`.
  */
 export declare class PieChart extends LineChart {
     /** Each row's start and end, as fractions of a turn clockwise from the top. */
@@ -18,18 +21,36 @@ export declare class PieChart extends LineChart {
     /** Percent formatters by fraction digits, rebuilt once per legend. */
     private _percents;
     protected get _type(): string;
-    protected get _key(): string;
+    /** A pie has no value axis. */
+    protected get _axis(): boolean;
     protected get _points(): boolean;
     protected get _circular(): boolean;
-    static init(el: HTMLElement, options?: Partial<PieChartOptions>): PieChart;
-    static init(els: InitElements<InitElement>, options?: Partial<PieChartOptions>): PieChart[];
-    static getInstance(el: HTMLElement): PieChart;
+    protected _read(): void;
+    /**
+     * The group's sum written like its cells: with their signs, and to their
+     * decimals, or compact when data-value stands behind text such as "$38M".
+     */
+    private _written;
+    private _precision;
+    /**
+     * Which rows data-other groups: those with a value under that percentage
+     * of the whole. Null when it groups nothing, as one small row is clearer
+     * by its own name.
+     */
+    private _small;
+    static key: string;
     show(index: number): void;
     /** CSS places the tooltip on the slice's middle from --turn. */
     protected _place(index: number): void;
     /** The row's share of the whole as a percentage, or '' for none. */
     private _share;
     private _percent;
+    /**
+     * Each slice's row name outside it, on the slice's middle, with a leader
+     * line back to the slice. Names on the right half run rightwards and those
+     * on the left run leftwards.
+     */
+    private _names;
     /** The legend: every row with its color, its cell and its share. */
     protected _guides(): Element[];
     /** The row under the pointer by its angle from the middle, or -1 off the slices. */
@@ -40,4 +61,8 @@ export declare class PieChart extends LineChart {
      * total are HTML over it.
      */
     protected _draw(): Element;
+    /** The .values shares on the slices and the .labels names outside them. */
+    private _texts;
+    /** Each slice's share on it, except on slices too thin to hold it. */
+    private _values;
 }

package/dist/types/components/pullToRefresh.d.ts

@@ -0,0 +1,80 @@
+import { Component, BaseOptions } from '../core/component';
+/** What `expressive:refresh` carries, and what `onRefresh` receives. */
+export interface PullToRefreshDetail {
+    /** Keeps the refresh running until the promise settles, fulfilled or rejected. */
+    waitUntil(promise: PromiseLike<unknown>): void;
+}
+/** What the container's status region announces. */
+export interface PullToRefreshI18nOptions {
+    /** Announced when a refresh starts. */
+    refreshing: string;
+    /** Announced when it finishes. */
+    refreshed: string;
+}
+export interface PullToRefreshOptions extends BaseOptions {
+    /**
+     * How far a finger must pull down, in pixels, for the release to refresh.
+     * A value that is not a positive number falls back to the default.
+     * @default 64
+     */
+    threshold: number;
+    /**
+     * Called when a refresh starts, with the event's detail.
+     * @default null
+     */
+    onRefresh: ((detail: PullToRefreshDetail) => void) | null;
+    /** What the status region announces when a refresh starts and finishes. */
+    i18n: Partial<PullToRefreshI18nOptions>;
+}
+/**
+ * Pull-to-refresh. A touch pull down from the top of the container, or a
+ * `[data-refresh]` button inside it, starts a refresh. The refresh runs until
+ * every promise passed to `waitUntil()` settles or the page calls `complete()`.
+ *
+ * Touch events rather than pointer events: a pointer drag the browser takes
+ * for a pan ends in `pointercancel`, and Safari has no directional
+ * `touch-action` to keep a downward pull from it. A mouse never fires touch
+ * events; a stylus does where the browser reports it as touch, as Safari on
+ * iPadOS does.
+ */
+export declare class PullToRefresh extends Component<PullToRefreshOptions> {
+    static key: string;
+    /** Where the finger went down and on what, while it may still become a pull. */
+    private _start;
+    private _pulling;
+    private _travel;
+    /** The running refresh. A new object each time, so a promise from an earlier one cannot end it. */
+    private _refresh;
+    /**
+     * Announces the start and the finish. The author's indicator cannot: it is
+     * hidden once the refresh ends, which would drop the finish.
+     */
+    private _status;
+    constructor(el: HTMLElement, options: Partial<PullToRefreshOptions>);
+    static get defaults(): PullToRefreshOptions;
+    /** Starts a refresh, as a pull or the refresh button does. Does nothing while one runs. */
+    refresh(): void;
+    /** Ends the running refresh: the indicator hides, `aria-busy` goes and the finish is announced. */
+    complete(): void;
+    destroy(): void;
+    /**
+     * Runs `onRefresh` and fires the event. A callback that throws ends the
+     * refresh it started, so later pulls still work, and the error still reaches the page.
+     */
+    private _fireRefresh;
+    /**
+     * Whether a downward drag from `target` would scroll something instead: a
+     * scrolled-down scroller inside the container, the container itself, or
+     * the scroller it sits in, which is the page when no ancestor scrolls.
+     */
+    private _canScrollUp;
+    private _onStart;
+    private _onMove;
+    /** Pulls once the finger moves down, or leaves the touch to scrolling when it moves another way first. */
+    private _decide;
+    /** Moves the indicator down with the finger, at half its travel, and fades it in toward the threshold. */
+    private _drag;
+    private _onEnd;
+    private _endPull;
+    private _onClick;
+}

package/dist/types/components/questionnaire.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 export interface QuestionnaireOptions extends BaseOptions {
     /**
      * Text above the progress bar. `{current}` and `{total}` are replaced with
@@ -14,6 +14,16 @@ export interface QuestionnaireOptions extends BaseOptions {
      * @default 'Choose an answer to continue.'
      */
     requiredMessage: string;
+    /**
+     * With `data-summary`, the heading of the review step and the text above
+     * the progress bar there.
+     * @default 'Review your answers'
+     */
+    summaryLabel: string;
+    /** With `data-summary`, the text of each answer's edit button. @default 'Edit' */
+    editLabel: string;
+    /** With `data-summary`, the answer shown for a question left blank. @default 'Not answered' */
+    skippedLabel: string;
 }
 /**
  * A multi-step questionnaire: a <form class="questionnaire"> whose
@@ -28,6 +38,12 @@ export interface QuestionnaireOptions extends BaseOptions {
  * clears its answer. A disabled fieldset is left out, so a page can switch
  * questions on and off from earlier answers.
  *
+ * Three attributes on the form add to that: `data-shortcuts` lets a letter or
+ * digit pick an answer, `data-summary` adds a review step listing every
+ * answer before the submit button, and `data-save="key"` keeps the answers
+ * and the shown question in localStorage under that key until the form is
+ * submitted.
+ *
  * Without JavaScript every question shows at once and the submit button sends
  * the form. The answers are ordinary form controls, so FormData reads them.
  */
@@ -42,21 +58,12 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     private _observer;
     /** Set while one submission's invalid events arrive, so only the first opens. */
     private _reporting;
-    constructor(el: HTMLFormElement, options: Partial<QuestionnaireOptions>);
+    /** With data-summary, the review step, and whether it is shown. */
+    private _summary;
+    private _reviewing;
+    constructor(el: HTMLElement, options: Partial<QuestionnaireOptions>);
     static get defaults(): QuestionnaireOptions;
-    /**
-     * Initializes instance of Questionnaire.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: HTMLElement, options?: Partial<QuestionnaireOptions>): Questionnaire;
-    /**
-     * Initializes instances of Questionnaire.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InitElement>, options?: Partial<QuestionnaireOptions>): Questionnaire[];
-    static getInstance(el: HTMLElement): Questionnaire;
+    static key: string;
     /** The questions that apply: every fieldset child that is not disabled. */
     get items(): HTMLFieldSetElement[];
     /** Position of the shown question in `items`. */
@@ -65,8 +72,12 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     goTo: (index: number) => void;
     /** Checks the shown question and moves to the next one if it is answered. */
     next: () => void;
-    /** Moves to the previous question. */
+    /** Moves to the previous question, or from the review step back to the last one. */
     previous: () => void;
+    /** Shows the review step of a questionnaire with data-summary. */
+    review: () => void;
+    /** The next question, or after the last one the review step. */
+    private _advance;
     /** Clears the answer to the shown question and moves to the next one. */
     skip: () => void;
     destroy(): void;
@@ -77,6 +88,34 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     private _required;
     private _ensureId;
     private _render;
+    /** The question after the shown one, which was switched off, or the last that applies. */
+    private _after;
+    /** Whether the shown step is the one that submits: the review step, or without one the last question. */
+    private get _end();
+    /** Whether a footer button applies to the shown step. */
+    private _shows;
+    /** Whether the shown question may be skipped: it applies and needs no answer. */
+    private _skippable;
+    private _renderProgress;
+    /** With data-summary, the review step: a list of the questions and their answers, before the footer. */
+    private _createSummary;
+    /** Lists each question that applies with its answer and a button back to it. */
+    private _fillSummary;
+    /** The storage key from data-save, or '' without it. */
+    private get _key();
+    /**
+     * Every answer control that can be saved, in order. A file cannot be put back,
+     * a password must not sit in storage, and a hidden input is the server's.
+     */
+    private _allControls;
+    /** With data-save, stores the answers and the shown question. */
+    private _save;
+    /** Puts back saved answers and the question they reached, if the questions are the same. */
+    private _restore;
+    /** The saved state, or null for none or a broken one. */
+    private _read;
+    /** A submitted questionnaire has nothing left to resume. */
+    private _forget;
     /**
      * Puts "choose at least one" on the first enabled checkbox of each
      * data-required group with none checked, so the browser's validation, and
@@ -91,6 +130,9 @@ export declare class Questionnaire extends Component<QuestionnaireOptions> {
     private _setInvalid;
     private _handleClick;
     private _handleKeydown;
+    /** Whether a shortcut key can pick an answer now: data-shortcuts is set and a question shows. */
+    private get _shortcuts();
+    private _handleShortcut;
     private _handleInvalid;
     private _handleInput;
 }

package/dist/types/components/radarChart.d.ts

@@ -1,4 +1,3 @@
-import { InitElements, InitElement } from '../core/component';
 import { LineChart, LineChartOptions } from './lineChart';
 export type RadarChartOptions = LineChartOptions;
 /**
@@ -7,17 +6,15 @@ export type RadarChartOptions = LineChartOptions;
  * shape joining its values on the spokes, from zero in the middle to the
  * scale's top at the rim. The row labels sit round the rim.
  *
- * Re-run `RadarChart.init(el)` after changing the table.
+ * Call `update()` after changing the table, or start it with `watch` or
+ * `data-watch`.
  */
 export declare class RadarChart extends LineChart {
     protected get _type(): string;
-    protected get _key(): string;
     /** The scale starts at zero, the middle, so shapes compare by size. */
     protected get _fromZero(): boolean;
     protected get _circular(): boolean;
-    static init(el: HTMLElement, options?: Partial<RadarChartOptions>): RadarChart;
-    static init(els: InitElements<InitElement>, options?: Partial<RadarChartOptions>): RadarChart[];
-    static getInstance(el: HTMLElement): RadarChart;
+    static key: string;
     /**
      * The cursor is a spoke turned by --turn, and the tooltip sits past its
      * tip. LineChart's points on the spoke keep their top, a share of the
@@ -30,6 +27,13 @@ export declare class RadarChart extends LineChart {
     protected _guides(): Element[];
     /** The nearest spoke to the pointer, by its angle from the middle. */
     protected _indexAt(e: PointerEvent): number;
+    /** The grid rings' shares of the radius: one per .axis label above zero, or quarters. */
+    private _rings;
+    /**
+     * One series' group: its outline, broken at a gap like a line chart's,
+     * its .area fill and its .points.
+     */
+    private _series;
     /**
      * An SVG in a -50 to 50 box: the rings and spokes of the grid, then each
      * series' shape, with its points for .points. The rim is the box's edge;

package/dist/types/components/radialChart.d.ts

@@ -1,31 +1,58 @@
-import { InitElements, InitElement } from '../core/component';
 import { LineChart, LineChartOptions } from './lineChart';
 export type RadialChartOptions = LineChartOptions;
 /**
  * Radial chart. It reads its <table> like LineChart, but draws each row of
  * the first value column as a ring, outermost first, filled clockwise from
  * the top as a share of `data-max` above zero (100 by default). With `.gauge` the rings
- * are half circles over the middle. A <tfoot> row shows in the middle, and
+ * are half circles over the middle. With `.labels` they are three quarters
+ * of a circle, leaving the top left quarter for each row's name at the
+ * ring's start; a gauge's names hang under its base line instead.
+ * `data-segments` splits each ring into that many segments, filled whole,
+ * and `.gradient` shades each fill along the ring, from a light tint at its
+ * start to its full color at its end. A <tfoot>
+ * row shows in the middle, and
  * a legend lists the rows when there is more than one. Further columns show
  * in the tooltip.
  *
- * Re-run `RadialChart.init(el)` after changing the table or the ring tokens.
+ * Call `update()` after changing the ring tokens, and after changing the table
+ * unless it was started with `watch` or `data-watch`.
  */
 export declare class RadialChart extends LineChart {
     /** Each ring's middle radius, and their shared width. */
     private _radii;
     private _width;
+    /** The gap between rings, and between segments. */
+    private _gap;
     /** Each row's share of the maximum, from 0 to 1. */
     private _fractions;
     private _rings;
+    /** With .gradient, each ring's fill drawn again as a conic gradient, or null for none. */
+    private _sweeps;
     protected get _type(): string;
-    protected get _key(): string;
+    /** The rings fill to data-max, so there is no value axis. */
+    protected get _axis(): boolean;
     protected get _points(): boolean;
     protected get _circular(): boolean;
     private get _gauge();
-    static init(el: HTMLElement, options?: Partial<RadialChartOptions>): RadialChart;
-    static init(els: InitElements<InitElement>, options?: Partial<RadialChartOptions>): RadialChart[];
-    static getInstance(el: HTMLElement): RadialChart;
+    /** Whether .labels names the rings, which a sparkline never does. */
+    private get _labeled();
+    /** How much of a circle a full ring spans. */
+    private get _span();
+    /** The number of segments data-segments asks for, or 0 for whole rings. */
+    private get _segments();
+    /** A share as drawn: with segments, to the nearest whole segment. */
+    private _lit;
+    /**
+     * A ring's dash pattern for a share of its span. Round caps reach half the
+     * width past each end of a dash, so a capped dash is one width shorter and
+     * its gap one width longer; one shorter than the width is a dot. With
+     * segments, each lit segment is a dash with the ring gap after it, and
+     * the last gap runs out the circle so the pattern does not repeat.
+     */
+    private _dash;
+    /** The distance between rings' middles, or one ring's width. */
+    private get _step();
+    static key: string;
     show(index: number): void;
     /** The tooltip sits where the ring's fill ends. */
     protected _place(index: number): void;
@@ -35,6 +62,30 @@ export declare class RadialChart extends LineChart {
     protected _guides(): Element[];
     /** The ring under the pointer by its distance from the middle, or -1. */
     protected _indexAt(e: PointerEvent): number;
+    /**
+     * How far a point is from the middle in the SVG's 100-unit box. In the
+     * top left quarter .labels leaves empty, the names run straight across,
+     * so only the height counts and a name picks its own ring.
+     */
+    private _distance;
+    /** Under a gauge's base line, the ring whose name is under the pointer, or -1. */
+    private _nameAt;
+    /** The rings' turn, from three o'clock to the top or, for a gauge, to nine, and the SVG's box. */
+    private get _frame();
+    /**
+     * With .gradient, a ring's fill drawn again in HTML: a conic gradient from
+     * a tint of its colour at the ring's start to the full colour where the
+     * fill ends, masked to the fill's own dash, so it follows the ring round.
+     * An SVG stroke takes no conic gradient.
+     */
+    private _sweep;
+    /**
+     * With .labels, each row's name left of its ring's start at the top,
+     * ending at the middle line. CSS shrinks the text to fit crowded rings.
+     * A gauge's names hang under its base line in a row each, innermost
+     * first, starting below their rings' starts.
+     */
+    private _names;
     /**
      * An SVG of rings in a -50 to 50 box, the top half for a gauge. Each row
      * is a track circle and a fill circle whose dash is its share; CSS draws

package/dist/types/components/registry.d.ts

@@ -11,7 +11,7 @@ import { isCardReveal } from "./cards";
  * is forgotten.
  *
  * A component that should only ever be constructed explicitly (Snackbar,
- * CharacterCounter, Range, ...) simply stays out of this table.
+ * CharacterCounter, ...) simply stays out of this table.
  */
 export declare const AUTO_INIT_COMPONENTS: {
     AppBar: {
@@ -55,6 +55,10 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.Keypad;
         selector: string;
     };
+    ColorPicker: {
+        component: typeof Components.ColorPicker;
+        selector: string;
+    };
     ColumnChart: {
         component: typeof Components.ColumnChart;
         selector: string;
@@ -83,6 +87,22 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.MixedChart;
         selector: string;
     };
+    ScatterChart: {
+        component: typeof Components.ScatterChart;
+        selector: string;
+    };
+    FunnelChart: {
+        component: typeof Components.FunnelChart;
+        selector: string;
+    };
+    SankeyChart: {
+        component: typeof Components.SankeyChart;
+        selector: string;
+    };
+    TreemapChart: {
+        component: typeof Components.TreemapChart;
+        selector: string;
+    };
     CommandPalette: {
         component: typeof Components.CommandPalette;
         selector: string;
@@ -107,6 +127,30 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.MessageScroller;
         selector: string;
     };
+    PullToRefresh: {
+        component: typeof Components.PullToRefresh;
+        selector: string;
+    };
+    LoadingOverlay: {
+        component: typeof Components.LoadingOverlay;
+        selector: string;
+    };
+    SwipeActions: {
+        component: typeof Components.SwipeActions;
+        selector: string;
+    };
+    InputMask: {
+        component: typeof Components.InputMask;
+        selector: string;
+    };
+    ShowMore: {
+        component: typeof Components.ShowMore;
+        selector: string;
+    };
+    CurrencyInput: {
+        component: typeof Components.CurrencyInput;
+        selector: string;
+    };
     Lightbox: {
         component: typeof Components.Lightbox;
         selector: string;
@@ -115,10 +159,22 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.ScrollSpy;
         selector: string;
     };
+    BackToTop: {
+        component: typeof Components.BackToTop;
+        selector: string;
+    };
     FormSelect: {
         component: typeof Components.FormSelect;
         selector: string;
     };
+    TreeSelect: {
+        component: typeof Components.TreeSelect;
+        selector: string;
+    };
+    Cascader: {
+        component: typeof Components.Cascader;
+        selector: string;
+    };
     NavigationRail: {
         component: typeof Components.NavigationRail;
         selector: string;
@@ -135,10 +191,18 @@ export declare const AUTO_INIT_COMPONENTS: {
         component: typeof Components.Tooltip;
         selector: string;
     };
+    HoverCard: {
+        component: typeof Components.HoverCard;
+        selector: string;
+    };
     FloatingActionButton: {
         component: typeof Components.FloatingActionButton;
         selector: string;
     };
+    Menubar: {
+        component: typeof Components.Menubar;
+        selector: string;
+    };
 };
 type Registry = typeof AUTO_INIT_COMPONENTS;
 /**
@@ -150,8 +214,14 @@ export type AutoInitOptions = {
 };
 /**
  * Automatically initialize components.
- * @param context Root element to initialize. Defaults to `document.body`.
+ * @param context Root element or shadow root to initialize. Defaults to
+ * `document.body`. Shadow roots inside it are not entered.
  * @param options Options for each component.
+ * @param settings With `watch: true`, keep starting components in markup
+ * added to `context` later, and destroy them when their markup is removed.
+ * @returns A function that stops watching. It does nothing without `watch`.
  */
-export declare function AutoInit(context?: HTMLElement, options?: Partial<AutoInitOptions>): void;
+export declare function AutoInit(context?: HTMLElement | ShadowRoot, options?: Partial<AutoInitOptions>, settings?: {
+    watch?: boolean;
+}): () => void;
 export {};

package/dist/types/components/richTextEditor.d.ts

@@ -1,4 +1,4 @@
-import { Component, BaseOptions, InitElements, InitElement } from '../core/component';
+import { Component, BaseOptions } from '../core/component';
 /**
  * The parts of a Tiptap `Editor` this component uses. Declared here so the
  * published types do not depend on Tiptap.
@@ -48,24 +48,16 @@ export declare class RichTextEditor extends Component<RichTextEditorOptions> {
     content: HTMLElement | null;
     private _actions;
     private _label;
+    private _required;
+    private _form;
     constructor(el: HTMLElement, options: Partial<RichTextEditorOptions>);
     static get defaults(): RichTextEditorOptions;
-    /**
-     * Initializes instance of RichTextEditor.
-     * @param el HTML element.
-     * @param options Component options.
-     */
-    static init(el: HTMLElement, options?: Partial<RichTextEditorOptions>): RichTextEditor;
-    /**
-     * Initializes instances of RichTextEditor.
-     * @param els HTML elements.
-     * @param options Component options.
-     */
-    static init(els: InitElements<InitElement>, options?: Partial<RichTextEditorOptions>): RichTextEditor[];
-    static getInstance(el: HTMLElement): RichTextEditor;
+    static key: string;
     destroy(): void;
     private _handleClick;
     private _handleLabelClick;
+    private _skipsValidation;
+    private _handleSubmit;
     private _handleUpdate;
     private _handleTransaction;
 }