@webority/ui-elements 0.149.0 → 0.150.0

package/types/WuiMarkdown.d.ts

@@ -0,0 +1,85 @@
+/**
+ * <wui-markdown>: the shared behaviour behind React AppMarkdown's text and Razor <app-markdown>.
+ * Both author the Markdown source as plain text and the element draws the blocks:
+ *
+ *   <wui-markdown class="wui-markdown" links="app" headings="text">
+ *     <pre class="wui-markdown-source">the source</pre>
+ *   </wui-markdown>
+ *
+ * Once connected it hides the source (it stays as the no-script fallback and the text the blocks are
+ * drawn from) and appends the blocks after it. The blocks come from @webority/markdown-core, the grammar
+ * every renderer reads, and every node is built with createElement and textContent, so the source is
+ * never read as HTML. The `links` attribute sets which links open and the `resolveLink` property maps
+ * an app address to a route; a link that does not open shows its label as text. The `base` attribute is an
+ * https origin a relative link resolves against; any other value is ignored. The `isCitation` property
+ * says which `[inner]` runs are citations: each draws as a chip button, and a click dispatches a bubbling
+ * `wui-markdown-citation` CustomEvent whose `detail` is `{ citation }`, the run's inner text. Changing the
+ * source, an attribute, `resolveLink` or `isCitation` redraws. The element is the only writer of what it
+ * adds. A root with no source child is left as it is, so React AppMarkdown draws its own blocks inside the
+ * same element.
+ */
+import type { FigureRun } from "@webority/markdown-core";
+import { ElementBase } from "./elementBase.ts";
+export type ResolveLink = (href: string) => string | null | undefined;
+export interface MarkdownDrawOptions {
+    /** Which links open; any other value draws as "web". */
+    links?: string | undefined;
+    /** "text" draws a heading as semibold text; any other value draws an h2. */
+    headings?: string | undefined;
+    /** An https origin a relative link resolves against. */
+    base?: string | undefined;
+    resolveLink?: ResolveLink | undefined;
+    isCitation?: ((inner: string) => boolean) | undefined;
+    figureText?: ((text: string) => FigureRun[]) | undefined;
+    resolverGeneration?: number | undefined;
+}
+export interface DrawnBlock {
+    sig: string;
+    nodes: Node[];
+}
+/**
+ * Parses a Markdown source once and draws each block as its own node list. A block's signature covers
+ * its content and the policies it is drawn under, so a block whose signature is unchanged can keep its nodes.
+ */
+export declare function drawMarkdownBlocks(doc: Document, source: string, options?: MarkdownDrawOptions): DrawnBlock[];
+/**
+ * Draws the blocks of a Markdown source as one flat list of DOM nodes, built with createElement and textContent only.
+ */
+export declare function drawMarkdown(doc: Document, source: string, options?: MarkdownDrawOptions): Node[];
+/**
+ * Makes the children of a container show the blocks of a Markdown source. A block whose signature matches
+ * the previous block at its index keeps its nodes, so focus, scroll and a finished code block survive a
+ * streamed redraw. Nodes go in after `afterNode`, or first when it is null; a node already in place is not moved.
+ *
+ * @param container
+ * @param previous the blocks an earlier call returned
+ * @param source
+ * @param options
+ * @param afterNode
+ */
+export declare function syncMarkdownBlocks(container: Element, previous: DrawnBlock[], source: string, options: MarkdownDrawOptions, afterNode?: Node | null): DrawnBlock[];
+export declare class WuiMarkdown extends ElementBase {
+    private _drawn;
+    private _blocks;
+    private _observer;
+    private _connected;
+    private _resolveLink;
+    private _isCitation;
+    private _resolverGeneration;
+    private _figureText;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    get resolveLink(): ResolveLink | undefined;
+    set resolveLink(v: ResolveLink | null | undefined);
+    get base(): string | undefined;
+    set base(v: unknown);
+    get isCitation(): ((inner: string) => boolean) | undefined;
+    set isCitation(v: ((inner: string) => boolean) | null | undefined);
+    get figureText(): ((text: string) => FigureRun[]) | undefined;
+    set figureText(v: ((text: string) => FigureRun[]) | null | undefined);
+    attributeChangedCallback(_name: string, previous: string | null, next: string | null): void;
+    _source(): HTMLPreElement | undefined;
+    _render(): void;
+}

package/types/WuiMentionInput.d.ts

@@ -0,0 +1,112 @@
+import { ElementBase } from "./elementBase.ts";
+/** A person the list offers. `value` is the public id the mention carries. */
+export interface MentionPerson {
+    value: string;
+    label: string;
+    description?: string | undefined;
+    src?: string | undefined;
+}
+/** A person mentioned in the text, each listed once. */
+export interface MentionRef {
+    id: string;
+    label: string;
+}
+export interface MentionText {
+    listName: string;
+    searching: string;
+    noMatch: string;
+    searchFailed: string;
+    found: (n: number) => string;
+    mentioned: (label: string) => string;
+}
+interface MentionQuery {
+    start: number;
+    end: number;
+    text: string;
+}
+/** The most people the list shows at once; a longer match narrows as the person types. */
+export declare const MENTION_MAX_RESULTS: number;
+/** The longest name fragment after "@" that still searches; past it the list closes. */
+export declare const MENTION_MAX_QUERY: number;
+/** The words the element says on its own. The Razor tag helper renders the same list name. */
+export declare const MENTION_TEXT: Readonly<MentionText>;
+/**
+ * Builds the shell into `host` from its attributes. Exported so the comment thread adds a box the
+ * same way; React and Razor never call it (Razor renders the shell, React leaves the host empty).
+ * @param host
+ */
+export declare function buildMentionShell(host: HTMLElement): void;
+export declare class WuiMentionInput extends ElementBase {
+    private _wired;
+    private _pendingValue;
+    private _text;
+    private _mentions;
+    private _peopleProp;
+    private _declared;
+    private _loading;
+    private _searchFailed;
+    private _query;
+    private _results;
+    private _active;
+    private _timer;
+    private _searchSeq;
+    private _lastSearch;
+    private _abort;
+    private _onMenuDown;
+    private _reposition;
+    _reanchor?: (() => void) | null;
+    _reanchorScroll?: ((e: Event) => void) | null;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    /** The stored value: plain text with @[Label](id) for each mention. */
+    get value(): string;
+    set value(v: unknown);
+    /** The people mentioned, each once: [{ id, label }]. */
+    get mentions(): MentionRef[];
+    /** The people the list offers: [{ value, label, description?, src? }]. */
+    get people(): MentionPerson[];
+    set people(list: unknown);
+    /** True after the people search failed: the list says so instead of "No one matches". New people clears it. */
+    get searchFailed(): boolean;
+    set searchFailed(b: unknown);
+    get loading(): boolean;
+    set loading(b: unknown);
+    focus(options?: FocusOptions): void;
+    /** Empty the box, as after a comment is posted. */
+    clear(): void;
+    _control(): HTMLTextAreaElement | null;
+    _menu(): HTMLElement | null;
+    private _requireControl;
+    private _requireMenu;
+    _load(value: string): void;
+    _syncField(): void;
+    _emit(): void;
+    _onInput(): void;
+    _onCaret(e?: Event): void;
+    _queryAtCaret(): MentionQuery | null;
+    _refresh(): void;
+    _answered(text: string): boolean;
+    _minChars(): number;
+    _debounce(): number;
+    _search(text: string): void;
+    _fetchPeople(source: string, text: string, mine: number): Promise<void>;
+    _isOpen(): boolean;
+    _renderMenu(): void;
+    _syncState(): void;
+    _position(): void;
+    _close(): void;
+    _setActive(i: number, { reveal }?: {
+        reveal?: boolean;
+    }): void;
+    _onKeyDown(e: KeyboardEvent): void;
+    _removeWholeMention(e: KeyboardEvent): void;
+    _onMenuClick(e: MouseEvent): void;
+    _pick(person: MentionPerson | undefined): void;
+    _replace(start: number, end: number, insert: string, mention?: MentionRef): void;
+    _onFocusOut(e: FocusEvent): void;
+    _announce(message: string): void;
+}
+export {};

package/types/WuiNavigationMenu.d.ts

@@ -0,0 +1,29 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiNavigationMenu extends ElementBase {
+    _onClick: (e: MouseEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onFocusOut: (e: FocusEvent) => void;
+    _onPointerDown: (e: PointerEvent) => void;
+    _onResize: () => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Open the panel whose button has `data-key` `key`, closing any other.
+     * @param key
+     */
+    open(key: string): void;
+    /** Close the open panel. `restoreFocus` returns focus to its button. */
+    close(restoreFocus?: boolean): void;
+    _items(): HTMLElement[];
+    _openItem(): HTMLElement | null;
+    _isTrigger(el: Element | null | undefined): boolean;
+    _entries(): HTMLElement[];
+    _links(item: Element): HTMLElement[];
+    _set(item: HTMLElement, open: boolean): void;
+    _align(panel: Element): void;
+    _handleClick(e: MouseEvent): void;
+    _handleKeyDown(e: KeyboardEvent): void;
+    _linkKey(e: KeyboardEvent, link: HTMLElement): void;
+    _teardown(): void;
+}

package/types/WuiNotificationCenter.d.ts

@@ -0,0 +1,34 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiNotificationCenter extends ElementBase {
+    _doc: Document | null;
+    _unread: number;
+    _busy: boolean;
+    _onClick: (e: MouseEvent) => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onOutside: (e: MouseEvent) => void;
+    _onFocusOut: (e: FocusEvent) => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    get isOpen(): boolean;
+    open(): void;
+    close({ restoreFocus }?: {
+        restoreFocus?: boolean;
+    }): void;
+    toggle(): void;
+    _announceToggle(): void;
+    _syncOpen(): void;
+    _initialUnread(): number;
+    _click(e: MouseEvent): void;
+    _key(e: KeyboardEvent): void;
+    _markItem(item: HTMLElement): void;
+    _markAll(): Promise<void>;
+    _pickTab(tab: HTMLElement): void;
+    _layoutTabs(): void;
+    _filterItems(key: string | undefined): void;
+    _applyRead(item: HTMLElement): void;
+    _setBusy(busy: boolean): void;
+    _render(): void;
+    _say(text: string): void;
+    _emitRead(ids: string[], all: boolean): void;
+}

package/types/WuiOnboardingChecklist.d.ts

@@ -0,0 +1,34 @@
+/**
+ * <wui-onboarding-checklist>: the collapse, dismiss and restore of an onboarding checklist. React
+ * AppOnboardingChecklist and Razor <app-onboarding-checklist> author the same markup; the element
+ * wires it:
+ *
+ *   <wui-onboarding-checklist class="wui-onboarding" [storage-key]>
+ *     <section class="wui-onboarding-card" [hidden]>   hidden once dismissed
+ *       <button class="wui-onboarding-toggle" aria-expanded aria-controls>   collapses the steps
+ *       <button class="wui-onboarding-dismiss">
+ *       <ol class="wui-onboarding-steps" [hidden]>   hidden while collapsed
+ *     </section>
+ *     <button class="wui-onboarding-restore" [hidden]>   shown once dismissed
+ *
+ * The markup is the state: `hidden` on the card is "dismissed", `hidden` on the steps is
+ * "collapsed". With `storage-key` a dismissal is kept in localStorage under `wui-onboarding:<key>`
+ * and applied when the element connects; restoring forgets it. Events (bubbling):
+ * `wui:onboarding:dismiss`, `wui:onboarding:restore` and `wui:onboarding:collapse` { collapsed }.
+ */
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiOnboardingChecklist extends ElementBase {
+    _onClick: (e: MouseEvent) => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    get dismissed(): boolean;
+    get collapsed(): boolean;
+    dismiss(): void;
+    restore(): void;
+    toggle(): void;
+    _setDismissed(dismissed: boolean): void;
+    _key(): string | null;
+    _stored(): string | null;
+    _store(value: string | null): void;
+}

package/types/WuiOrgTree.d.ts

@@ -0,0 +1,50 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiOrgTree extends ElementBase {
+    static get observedAttributes(): string[];
+    _query: string;
+    _snapshot: Map<string | null, boolean> | null;
+    _observer: MutationObserver | null;
+    _announceTimer: number | undefined;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onClick: (e: MouseEvent) => void;
+    _onFocusIn: (e: FocusEvent) => void;
+    _onInput: (e: Event) => void;
+    _onBeforePrint: () => void;
+    _onAfterPrint: () => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    get selected(): string | null;
+    set selected(id: string | null | undefined);
+    get selectable(): boolean;
+    set selectable(on: boolean);
+    _items(): HTMLElement[];
+    _hasChildren(li: HTMLElement): boolean;
+    _isVisible(li: Element): boolean;
+    _visibleItems(): HTMLElement[];
+    _parentItem(li: HTMLElement): HTMLElement | null;
+    _visibleChildren(li: HTMLElement): HTMLElement[];
+    _isVisibleItem(el: Element | null): el is HTMLElement;
+    _siblingItem(li: HTMLElement, direction: "nextElementSibling" | "previousElementSibling"): HTMLElement | null;
+    _setRoving(li: HTMLElement): void;
+    _focusItem(li: HTMLElement | null | undefined): void;
+    _toggleLabel(li: HTMLElement, open: boolean): string;
+    _setExpanded(li: HTMLElement, open: boolean): void;
+    _toggle(li: HTMLElement): void;
+    _syncToggles(): void;
+    _applySelected(): void;
+    _select(li: HTMLElement): void;
+    _activate(li: HTMLElement): void;
+    _handleFocusIn(e: FocusEvent): void;
+    _handleClick(e: MouseEvent): void;
+    _handleKeyDown(e: KeyboardEvent): void;
+    _handleInput(e: Event): void;
+    _search(query: string): void;
+    _captureExpanded(): Map<string | null, boolean>;
+    _restore(snapshot: Map<string | null, boolean>): void;
+    _applySearch(query: string): void;
+    _resultText(): string;
+    _announce(text: string): void;
+    _scaleForPrint(): void;
+}

package/types/WuiOtp.d.ts

@@ -0,0 +1,32 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiOtp extends ElementBase {
+    static formAssociated: boolean;
+    static get observedAttributes(): string[];
+    _value: string;
+    _defaultValue: string | undefined;
+    _defaultCaptured: boolean | undefined;
+    _rendered: boolean | undefined;
+    _onSelectionChange: (() => void) | undefined;
+    _internals: ElementInternals | null;
+    get length(): number;
+    set length(v: number | string);
+    get mode(): "numeric" | "alphanumeric";
+    set mode(v: string | null | undefined);
+    get value(): string;
+    set value(v: unknown);
+    /** Strip anything the mode does not allow, then cap at `length`. */
+    _clean(raw: unknown): string;
+    constructor();
+    connectedCallback(): void;
+    formResetCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, val: string | null): void;
+    render(): void;
+    _refs(): {
+        input: HTMLInputElement | null;
+        slots: HTMLElement[];
+    };
+    /** Mirror the value into the segment spans and mark the one the caret sits in. */
+    _paint(): void;
+    _wire(): void;
+    disconnectedCallback(): void;
+}

package/types/WuiOverflow.d.ts

@@ -0,0 +1,29 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiOverflow extends ElementBase {
+    _more: HTMLButtonElement;
+    _menu: HTMLDivElement;
+    _hiddenKey: string;
+    _ro: ResizeObserver | null;
+    _mo: MutationObserver | null;
+    _observedList: Element | null;
+    _doc: Document | null;
+    _onDocDown: (e: PointerEvent) => void;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    static get observedAttributes(): string[];
+    attributeChangedCallback(): void;
+    _label(): string;
+    _list(): HTMLElement | null;
+    _items(list: HTMLElement): HTMLElement[];
+    _build(): void;
+    _watch(): void;
+    /** Re-decides which items fit. Safe to call at any time. */
+    layout(): void;
+    _hiddenItems(): HTMLElement[];
+    _fill(hidden: HTMLElement[]): void;
+    _choose(item: HTMLElement, action: HTMLElement): void;
+    _open(focusFirst: boolean): void;
+    _close(restoreFocus: boolean): void;
+    _onMenuKey(e: KeyboardEvent): void;
+}

package/types/WuiPhone.d.ts

@@ -0,0 +1,37 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiPhone extends ElementBase {
+    static formAssociated: boolean;
+    static get observedAttributes(): string[];
+    _internals: ElementInternals | null;
+    _defaultCountry: string;
+    _country: string;
+    _national: string;
+    _active: number;
+    _committedValue: string;
+    _validateOnInput: boolean;
+    _defaultValue: string | undefined;
+    _rendered: boolean | undefined;
+    _listboxId: string;
+    _suppressCountryRender: boolean;
+    _bindGlobal: (() => void) | undefined;
+    _teardownGlobals: (() => void) | undefined;
+    _onDocClick: ((e: MouseEvent) => void) | null;
+    constructor();
+    connectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, val: string | null): void;
+    formResetCallback(): void;
+    get _locked(): string | null;
+    get value(): string;
+    set value(v: unknown);
+    _syncMirror(): void;
+    _syncDescribedBy(): void;
+    _emitInput(): void;
+    _emitChange(): void;
+    render(): void;
+    _ensureItems(): void;
+    _itemEls(): HTMLElement[];
+    _visibleItems(): HTMLElement[];
+    _wire(): void;
+    _teardown(): void;
+    disconnectedCallback(): void;
+}

package/types/WuiRating.d.ts

@@ -0,0 +1,17 @@
+/**
+ * <wui-rating>: the behaviour of a star rating input. React AppRating and Razor <app-rating> render
+ * a radiogroup of labelled radios inside it (arrow keys, focus and the form value are the native
+ * radios'); the element keeps the drawn stars in step with the chosen value, and previews the
+ * star under the pointer. A `disabled` attribute turns the preview off.
+ */
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiRating extends ElementBase {
+    private _onChange;
+    private _onOver;
+    private _onLeave;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    _fill(value: number): void;
+    _preview(upTo: number): void;
+}

package/types/WuiRecordPager.d.ts

@@ -0,0 +1,9 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiRecordPager extends ElementBase {
+    private _doc;
+    private _onKeyDown;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    _press(selector: string): void;
+}

package/types/WuiRelativeTime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * <wui-relative-time>: keeps the text of its `<time datetime>` child current ("5 minutes ago").
+ * React AppRelativeTime and Razor <app-relative-time> render the element with the time's date as
+ * the first text and the exact IST time as the tooltip; this swaps the text in on connect and
+ * every 30 seconds after, for all instances on one timer that stops with the last one. A hidden
+ * tab skips the tick and catches up when it is shown again. A change to the child (a new
+ * `datetime`, a re-render) is re-read at once.
+ */
+import { ElementBase } from "./elementBase.ts";
+export declare const RELATIVE_TICK_MS = 30000;
+export declare class WuiRelativeTime extends ElementBase {
+    private _observer;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    refresh(): void;
+}

package/types/WuiResizable.d.ts

@@ -0,0 +1,79 @@
+/**
+ * <wui-resizable>: panels the person resizes by dragging a handle or with the keyboard. The behaviour
+ * behind React AppResizable and Razor <app-resizable>; it decorates server-rendered markup and draws
+ * nothing of its own. Direct children, in order:
+ *
+ *   <wui-resizable class="wui-resizable" direction="horizontal" storage-key="inbox-split">
+ *     <div class="wui-resizable-panel" data-default-size="30" data-min-size="15" data-max-size="60">...</div>
+ *     <div class="wui-resizable-handle" role="separator" tabindex="0" aria-orientation="vertical"></div>
+ *     <div class="wui-resizable-panel">...</div>
+ *   </wui-resizable>
+ *
+ * A handle resizes the panel before it against the panel after it. Sizes are percentages of the room
+ * the panels share (the handles' own width is left out) and always add up to 100; a panel without
+ * `data-default-size` shares what the sized ones leave. `data-min-size` defaults to 10, `data-max-size`
+ * to 100. The element writes each panel's `flex` and the handle's aria-valuenow, -valuemin, -valuemax and
+ * aria-controls (WAI-ARIA window splitter).
+ *
+ * Attributes
+ *   direction    horizontal (default: panels side by side) | vertical (stacked; give the group a height).
+ *   storage-key  Remember the sizes in localStorage under this key (one per screen). A stored layout
+ *                that no longer fits the panels is ignored.
+ *
+ * Pointer and touch drag a handle (pointer capture, so the drag survives leaving it); the arrow keys of
+ * the axis move it 5%, with Shift 20%; Home and End take the panel before it to its minimum and maximum;
+ * double click or double tap restores the default sizes.
+ *
+ * Event (bubbles)
+ *   wui-resizable:change  detail { sizes }  after a drag or key press that changed the layout, and
+ *                         after a reset; never while a drag is still moving.
+ */
+import { ElementBase } from "./elementBase.ts";
+interface HandleHit {
+    handle: HTMLElement;
+    index: number;
+}
+/** Sizes within each panel's bounds that add up to 100, spreading any shortfall over the panels with room. */
+export declare function fitSizes(sizes: number[], mins: number[], maxs: number[]): number[];
+/** The lowest and highest size panel `index` can take against the panel after it. */
+export declare function pairRange(sizes: number[], index: number, mins: number[], maxs: number[]): [number, number];
+/** Moves `delta` percent from the panel after `index` to the panel at `index`, within both bounds. */
+export declare function resizeAt(sizes: number[], index: number, delta: number, mins: number[], maxs: number[]): number[];
+/** The starting sizes: the declared ones, the rest sharing what is left; scaled to 100 when they do not add up. */
+export declare function defaultSizes(declared: (number | null)[]): number[];
+export declare class WuiResizable extends ElementBase {
+    private _panels;
+    private _handles;
+    private _mins;
+    private _maxs;
+    private _defaults;
+    private _sizes;
+    private _drag;
+    private _observer;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerUp;
+    private _onPointerCancel;
+    private _onKeyDown;
+    private _onDoubleClick;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** The current sizes in percent, one per panel. */
+    get sizes(): number[];
+    get _vertical(): boolean;
+    _sync(): void;
+    _render(): void;
+    _indexOf(handle: Element): number;
+    _handleFor(e: Event): HandleHit | null;
+    _storageKey(): string | null;
+    _load(count: number): number[] | null;
+    _save(): void;
+    _commit(before: number[]): void;
+    _pointerDown(e: PointerEvent): void;
+    _pointerMove(e: PointerEvent): void;
+    _pointerUp(e: PointerEvent, cancelled: boolean): void;
+    _keyDown(e: KeyboardEvent): void;
+    _reset(e: MouseEvent): void;
+}
+export {};

package/types/WuiRichText.d.ts

@@ -0,0 +1,45 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiRichText extends ElementBase {
+    static formAssociated: boolean;
+    private _value;
+    private _lastSet;
+    private _committed;
+    private _editor;
+    private _internals;
+    private _initial;
+    private _seeded;
+    private _abort;
+    private get _toolbar();
+    private get _linkbar();
+    private get _linkInput();
+    private get _linkError();
+    private get _mounted();
+    static get observedAttributes(): string[];
+    constructor();
+    get value(): string;
+    set value(next: string | null | undefined);
+    get format(): "html" | "markdown";
+    set format(v: string | null | undefined);
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string): void;
+    formResetCallback(): void;
+    focus(options?: FocusOptions): void;
+    _surfaceAttributes(): Record<string, string>;
+    _build(): void;
+    _teardown(): void;
+    _isEditable(): boolean;
+    _syncEditable(): void;
+    _syncMirror(): void;
+    _syncValidity(): void;
+    _afterValueChange(): void;
+    _onEdit(): void;
+    _onBlur(): void;
+    _buttons(): HTMLButtonElement[];
+    _syncToolbar(): void;
+    _wire(): void;
+    _toolbarKey(e: KeyboardEvent): void;
+    _openLinkBar(): void;
+    _closeLinkBar(): void;
+    _applyLink(): void;
+}

package/types/WuiRollingNumber.d.ts

@@ -0,0 +1,27 @@
+/**
+ * <wui-rolling-number>: a figure that rolls its digits to a new value. React AppRollingNumber and
+ * Razor <app-rolling-number> render the final text (read once by a screen reader) and an empty
+ * aria-hidden roll. This element keeps that text current, formats `value` with the shared
+ * formatters, draws one reel per digit in the roll and, when `value` changes, moves each reel to
+ * its new digit. Non-digit characters (the rupee sign, commas, the point) stay put. The first draw
+ * never animates, and under prefers-reduced-motion the roll is left empty so the plain text shows
+ * and nothing moves.
+ */
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiRollingNumber extends ElementBase {
+    private _connected;
+    private _signature;
+    private _digits;
+    private _reels;
+    private _roll;
+    private _onRollEnd;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(): void;
+    _text(): string | null;
+    _showText(text: string): void;
+    _clear(roll: HTMLElement): void;
+    _draw(animate: boolean): void;
+}