@webority/ui-elements 0.149.0 → 0.152.0

package/types/WuiTree.d.ts

@@ -0,0 +1,112 @@
+import { ElementBase } from "./elementBase.ts";
+import { createListboxKeyNav } from "./listboxKeyNav.ts";
+export interface WuiTreeNode {
+    id?: string | number | null;
+    label?: string | number | null;
+    icon?: string | null;
+    badge?: string | number | null;
+    badgeTone?: string | null;
+    children?: WuiTreeNode[];
+    hasChildren?: boolean;
+    expanded?: boolean;
+    checked?: boolean;
+    disabled?: boolean;
+}
+type LoadChildren = (node: WuiTreeNode) => Promise<WuiTreeNode[]>;
+type Selection = "none" | "single" | "multiple";
+type CheckState = "checked" | "unchecked" | "mixed";
+interface TreeModelNode {
+    id: string;
+    raw: WuiTreeNode;
+    parent: TreeModelNode | null;
+    level: number;
+    seq: number;
+    label: string;
+    icon: string | null;
+    badge: string | null;
+    badgeTone: string | null;
+    disabled: boolean;
+    hasChildren: boolean;
+    children: TreeModelNode[] | null;
+    expanded: boolean;
+    loading: boolean;
+    failed: boolean;
+}
+export declare class WuiTree extends ElementBase {
+    _uid: string;
+    _seq: number;
+    _roots: TreeModelNode[];
+    _byId: Map<string, TreeModelNode>;
+    _prev: Map<string, TreeModelNode> | null;
+    _staged: {
+        ids: string[];
+        checks: string[];
+    } | null;
+    _els: Map<string, {
+        li: HTMLLIElement;
+        row: HTMLDivElement;
+    }>;
+    _checked: Set<string>;
+    _selected: string | null;
+    _focusId: string | null;
+    _loader: LoadChildren | null;
+    _list: HTMLUListElement | null;
+    _live: HTMLDivElement | null;
+    _ready: boolean;
+    _nav: ReturnType<typeof createListboxKeyNav>;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onClick: (e: MouseEvent) => void;
+    _onFocusIn: (e: FocusEvent) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    get nodes(): WuiTreeNode[];
+    set nodes(list: WuiTreeNode[] | null | undefined);
+    get selection(): Selection;
+    set selection(v: string);
+    get selected(): string | null;
+    set selected(id: string | number | null | undefined);
+    get values(): string[];
+    set values(ids: (string | number)[] | null | undefined);
+    get loadChildren(): LoadChildren | null;
+    set loadChildren(fn: LoadChildren | null | undefined);
+    get loadUrl(): string | null;
+    set loadUrl(v: string | null | undefined);
+    get name(): string | null;
+    set name(v: string | null | undefined);
+    get loadingText(): string;
+    set loadingText(v: string | null | undefined);
+    get errorText(): string;
+    set errorText(v: string | null | undefined);
+    _readScript(): WuiTreeNode[] | null;
+    _adoptAll(rawList: WuiTreeNode[]): void;
+    _adoptStaged(rawList: WuiTreeNode[], parent: TreeModelNode | null, level: number): TreeModelNode[];
+    _adopt(rawList: WuiTreeNode[], parent: TreeModelNode | null, level: number): TreeModelNode[];
+    _passChecksDown(n: TreeModelNode): void;
+    _loadOpenNodes(): void;
+    _isBranch(n: TreeModelNode): boolean;
+    _visible(): TreeModelNode[];
+    _state(n: TreeModelNode): CheckState;
+    _setChecked(n: TreeModelNode, on: boolean): void;
+    _nodeFrom(target: EventTarget | null): TreeModelNode | null;
+    _emit(name: string, detail: unknown): void;
+    _announce(text: string): void;
+    _setRoving(n: TreeModelNode): void;
+    _focusNode(n: TreeModelNode | undefined): void;
+    _activate(n: TreeModelNode): void;
+    _enabledLeaves(n: TreeModelNode): TreeModelNode[];
+    _toggleCheck(n: TreeModelNode): void;
+    _toggleExpand(n: TreeModelNode): void;
+    _expand(n: TreeModelNode): void;
+    _load(n: TreeModelNode): Promise<void>;
+    _fetchChildren(n: TreeModelNode): Promise<WuiTreeNode[]>;
+    _handleClick(e: MouseEvent): void;
+    _handleKeyDown(e: KeyboardEvent): void;
+    _syncForm(): void;
+    _render(): void;
+    _buildLevel(nodes: TreeModelNode[]): HTMLLIElement[];
+    _buildItem(n: TreeModelNode, posInSet: number, setSize: number): HTMLLIElement;
+}
+export {};

package/types/WuiTruncate.d.ts

@@ -0,0 +1,19 @@
+/**
+ * <wui-truncate>: shows the full text of a clipped `.wui-truncate-text` child. React AppTruncate and
+ * Razor <app-truncate> render the element around the clipped span; when the text really is cut
+ * (by width or by line count) the element sets `data-wui-tip` to the whole text, which the theme
+ * draws as a tooltip on hover and keyboard focus, and makes itself focusable so a keyboard user
+ * can reach it. Text that fits gets neither. It re-measures when the box resizes or the text
+ * changes, and on hover.
+ */
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiTruncate extends ElementBase {
+    _measure: () => void;
+    _resize: ResizeObserver | null;
+    _mutation: MutationObserver | null;
+    _ownTabindex: boolean;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    measure(): void;
+}

package/types/WuiWhatsNew.d.ts

@@ -0,0 +1,36 @@
+import { ElementBase } from "./elementBase.ts";
+export declare const WHATS_NEW_READ_EVENT = "wui-whats-new-read";
+export declare class WuiWhatsNew extends ElementBase {
+    _doc: Document | null;
+    _stored: string;
+    _observer: MutationObserver | null;
+    _onTriggerClick: () => void;
+    _onKeyDown: (e: KeyboardEvent) => void;
+    _onPointerDown: (e: PointerEvent) => void;
+    static get observedAttributes(): string[];
+    constructor();
+    get isOpen(): boolean;
+    get _trigger(): HTMLElement | null;
+    get _panel(): HTMLElement | null;
+    get _dot(): HTMLElement | null;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    open(): void;
+    close(returnFocus: boolean): void;
+    _place(): void;
+    _entries(): {
+        entry: HTMLElement;
+        date: string;
+    }[];
+    _newest(): string;
+    _seenPoint(): string;
+    _refresh(): void;
+    _markRead(): void;
+    _storage(): {
+        store: Storage;
+        key: string;
+    } | null;
+    _load(): string;
+    _save(date: string): void;
+}

package/types/WuiWizard.d.ts

@@ -0,0 +1,78 @@
+import { ElementBase } from "./elementBase.ts";
+import { type StepStatus } from "./stepperHeader.ts";
+type BeforeNext = (index: number) => boolean | Promise<boolean>;
+type FocusKey = {
+    attr: string;
+    value: string | null;
+};
+export declare class WuiWizard extends ElementBase {
+    _active: number;
+    _skipped: Set<number>;
+    _invalid: Set<number>;
+    _finished: boolean;
+    _rendered: boolean;
+    _reflecting: boolean;
+    _beforeNext: BeforeNext | null;
+    _header: HTMLElement;
+    _footer: HTMLElement;
+    _chromeInserted: boolean;
+    _topBar: HTMLElement | null;
+    _onTopBarClick: (e: MouseEvent) => void;
+    _onHeaderClick?: (e: MouseEvent) => void;
+    _onFooterClick?: (e: MouseEvent) => void;
+    _known: HTMLElement[];
+    _observer: MutationObserver | null;
+    _glyphs: Element | null;
+    _glyphObserver: MutationObserver | null;
+    static get observedAttributes(): string[];
+    constructor();
+    get active(): number;
+    set active(v: string | number);
+    /** A gate run before advancing on Next: `(index) => boolean | Promise<boolean>`. */
+    get beforeNext(): BeforeNext | null;
+    set beforeNext(fn: BeforeNext | null | undefined);
+    /**
+     * The `<wui-wizard-step>` panels, in order. Underscore-prefixed (internal): a public
+     * getter-only accessor would throw if React ever set `steps` as an element property, so
+     * the step set is exposed only as the `steps` React prop / `<app-wizard-step>` children.
+     */
+    get _steps(): HTMLElement[];
+    /** Rebuild the header + footer without moving panels, for a changed step set. */
+    refresh(): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, _old: string | null, value: string | null): void;
+    render(): void;
+    _renderChrome(): void;
+    /** The attribute and value naming the chrome control that holds focus, so a redraw can hand focus back. */
+    _focusedControl(): FocusKey | null;
+    _restoreFocus(focused: FocusKey | null): void;
+    _syncTopBar(steps: HTMLElement[]): void;
+    _clampActive(steps: HTMLElement[]): void;
+    /**
+     * Bring the index-keyed state (active, skipped, invalid) onto the live step set by element
+     * identity. A no-op when the set is unchanged since the last render. Returns the live steps.
+     */
+    _reconcileSteps(): HTMLElement[];
+    _placeChrome(steps: HTMLElement[]): void;
+    _onStepsMutated(): void;
+    _syncPanels(steps: HTMLElement[]): void;
+    _stepStatus(step: Element | undefined, i: number): StepStatus;
+    _headerHtml(steps: HTMLElement[]): string;
+    _footerHtml(steps: HTMLElement[]): string;
+    _wire(): void;
+    /** The wrapper's pre-styled glyph for `name`, else the linear one. */
+    _glyph(name: string): string;
+    _watchGlyphs(): void;
+    _renderHeader(): void;
+    _teardown(): void;
+    _stepTo(index: number): void;
+    _back(): void;
+    _next(): Promise<void>;
+    _skip(): void;
+    _flagInvalid(i: number): void;
+    _finish(): void;
+    _go(index: number, reason: string): void;
+    _reflectActive(index: number): void;
+}
+export {};

package/types/WuiWizardStep.d.ts

@@ -0,0 +1,5 @@
+import { ElementBase } from "./elementBase.ts";
+export declare class WuiWizardStep extends ElementBase {
+    static get observedAttributes(): string[];
+    attributeChangedCallback(): void;
+}

package/types/anchorOverlay.d.ts

@@ -0,0 +1,75 @@
+export interface ReanchorHost {
+    _reanchor?: (() => void) | null;
+    _reanchorScroll?: ((e: Event) => void) | null;
+}
+export type ReanchoredElement = {
+    _reanchor: () => void;
+};
+/**
+ * Anchor `panel` to `trigger`, flipping above it when there is not enough room below.
+ *
+ * @param trigger the control the panel belongs to
+ * @param panel   the floating panel, already visible so it can be measured
+ * @param opts    `matchWidth`, `clampHeight`, `alignEnd`, `below` and `beside`, each optional and false by default.
+ *   `below` never flips above, for a panel pinned open by an attribute: whether it flips depends on
+ *   the viewport at upgrade time, so the same markup would open differently on each page.
+ *   `matchWidth` ties the panel to the trigger's width: right for a menu that reads as part of
+ *   its control, wrong for a calendar with its own natural size. This is a MINIMUM, not a lock:
+ *   the panel is at least as wide as the trigger but grows to fit its content, so a narrow
+ *   control can't force long option labels to wrap (capped to the viewport). A wide-enough
+ *   control still gets an exactly-flush menu.
+ *
+ *   `clampHeight` caps the panel to whichever side (above/below) the flip above picked, so a
+ *   panel taller than that side's room shrinks to fit and scrolls internally instead of running
+ *   past the fold unreachable (see the module doc). Opt-in: a panel that already owns an inner
+ *   scroll region for its variable-length content (an options list inside a fixed-height shell)
+ *   would otherwise get its OUTER box clamped too, clipping that inner list instead of the
+ *   outer box growing to fit it, a regression for a shape this flag isn't meant to touch. Use
+ *   it only where the panel's own top-level box is the thing that needs to fit and scroll,
+ *   e.g. a full calendar grid with no inner scroll container.
+ *
+ *   `alignEnd` lines the panel's right edge up with the trigger's right edge instead of its left
+ *   edge: right for a panel opened by a control at the end of a row, such as a filter button. When
+ *   the panel doesn't fit to the left of the trigger's end, it aligns to the trigger's start instead.
+ *   The left edge stays 8 px or more from the viewport's left edge even when the panel is wider than
+ *   the viewport.
+ *
+ *   `beside` places the panel to the right of the trigger, top-aligned with it, and flips it to the
+ *   left when the right side would overflow. It keeps the panel inside the viewport vertically and
+ *   sets `data-side` to "end" or "start" for the side it chose. For a submenu opened from its row.
+ */
+export declare function anchorOverlay(trigger: Pick<HTMLElement, "getBoundingClientRect"> | null, panel: HTMLElement | null, opts?: {
+    matchWidth?: boolean;
+    clampHeight?: boolean;
+    alignEnd?: boolean;
+    below?: boolean;
+    beside?: boolean;
+}): void;
+/**
+ * Keep an open panel anchored while the page moves under it.
+ *
+ * A fixed panel is positioned once, at open, against coordinates that stop being true the
+ * moment anything scrolls or the window resizes — so it detaches from its control and floats
+ * over unrelated content. `scroll` is listened for in the CAPTURE phase because scroll does
+ * not bubble: a control inside a scrolling table or modal body would otherwise never be told.
+ *
+ * Here rather than in each element for the same reason `anchorOverlay` is: four copies of a
+ * rule is four chances to diverge. The specific trap is that `removeEventListener` only
+ * matches when the capture flag matches — pass `true` on add and forget it on remove and the
+ * listener silently survives, so every re-wire stacks another one onto a global event.
+ *
+ * Capture also sees scroll events the panel dispatches on ITSELF (its own clampHeight
+ * calendar, an option list), because capture walks every descendant regardless of bubbling.
+ * Repositioning against one of those recomputes the same (unchanged) trigger rect while
+ * fighting the gesture that produced it, and for a clampHeight panel it re-measures with
+ * `style.maxHeight` momentarily cleared, which resets `scrollTop` to 0 on every tick: the
+ * panel LOOKS scrollable but every scroll snaps back. Skip reposition when the host is in the
+ * scroll's event path; only a scroll OUTSIDE it (the page, a modal body, a scrolling table)
+ * means the trigger itself may have moved.
+ *
+ * @param host the custom element, which owns the handler for its lifetime
+ * @param reposition called on scroll/resize; decides for itself whether it is open
+ */
+export declare function bindReanchor(host: ReanchorHost & EventTarget, reposition: () => void): void;
+/** Release what {@link bindReanchor} added. Safe to call when nothing is bound. */
+export declare function unbindReanchor(host: (ReanchorHost & EventTarget) | null | undefined): void;

package/types/avatarHtml.d.ts

@@ -0,0 +1,10 @@
+/**
+ * An image URL is option DATA (it can come from an API), so only a web or root-relative URL,
+ * or an inline raster image, may reach `src`. Anything else renders the initials alone.
+ */
+export declare const safeImageUrl: (url: unknown) => string;
+/** The avatar face for an option, or "" when it has neither a usable photo nor initials. */
+export declare const avatarHtml: (o: {
+    avatar?: unknown;
+    initials?: string | null;
+}, sizeClass?: string) => string;

package/types/avatarPicker.d.ts

@@ -0,0 +1,47 @@
+/** Phone cameras save HEIC; the browser decides whether it can open one (see avatarUnreadableMessage). */
+export declare const AVATAR_ACCEPT = "image/jpeg,image/png,image/webp,image/heic,image/heif,.heic,.heif";
+/** The limit on the photo the person CHOOSES; the saved crop is far smaller. */
+export declare const AVATAR_MAX_SIZE_MB = 10;
+/** Width and height of the saved square, in px. */
+export declare const AVATAR_OUTPUT_SIZE = 512;
+/** Asked of the canvas; a browser that cannot encode WebP hands back PNG, and the file is named for it. */
+export declare const AVATAR_OUTPUT_TYPE = "image/webp";
+/** The two live previews in the crop dialog, in px. */
+export declare const AVATAR_PREVIEW_SIZES: number[];
+export declare const AVATAR_TEXT: {
+    dialogTitle: string;
+    dialogSubtitle: string;
+    save: string;
+    cancel: string;
+    choose: string;
+    change: string;
+    camera: string;
+    remove: string;
+    unreadable: string;
+    heicUnreadable: string;
+    cropFailed: string;
+};
+/** Is this a HEIC/HEIF photo? Windows reports an empty type for one, so the name decides then. */
+export declare function isHeicFile(file: {
+    name?: string;
+    type?: string;
+} | null): boolean;
+/** What to say when the crop element cannot decode the chosen photo. */
+export declare function avatarUnreadableMessage(file: {
+    name?: string;
+    type?: string;
+} | null): string;
+/**
+ * The options both pickers pass to <wui-image-crop>.toFile(): the original's name, WebP, and the
+ * exact square size. A size that is not a positive whole number takes the default.
+ *
+ * @param file the original photo, or null
+ * @param outputSize the square size in px
+ */
+export declare function avatarCropOptions(file: {
+    name?: string;
+} | null, outputSize?: number): {
+    name: string;
+    type: string;
+    size: number;
+};

package/types/buttonClass.d.ts

@@ -0,0 +1,8 @@
+export declare const APP_BUTTON_MARKER: string;
+/**
+ * @param tone an AppButton tone; an unknown one throws, because it is a library bug.
+ * @param variant an AppButton variant; an unknown one throws, because it is a library bug.
+ * @param size
+ * @returns e.g. "btn btn-ghost-primary btn-sm"
+ */
+export declare function buttonClass(tone?: string, variant?: string, size?: "sm" | "md" | "lg"): string;

package/types/calendar.d.ts

@@ -0,0 +1,3 @@
+import { WuiCalendar } from "./WuiCalendar.ts";
+export { CALENDAR_TONES, CALENDAR_VIEWS } from "./calendarModel.ts";
+export { WuiCalendar };

package/types/calendarAdapter.d.ts

@@ -0,0 +1,68 @@
+import type { normalizeEvents } from "./calendarModel.ts";
+export type ViewName = "month" | "week" | "day" | "list";
+type NormalizedEvent = ReturnType<typeof normalizeEvents>[number];
+interface RangeState {
+    view: ViewName;
+    title: string;
+    start: string;
+    end: string;
+    date: string;
+}
+interface MountOptions {
+    view: ViewName;
+    date?: string;
+    timeZone?: string;
+    firstDay: number;
+    emptyText: string;
+    fetchEvents: (range: {
+        start: string;
+        end: string;
+        view: ViewName;
+    }) => Promise<NormalizedEvent[]>;
+    onEventClick: (event: NormalizedEvent, native: MouseEvent | KeyboardEvent) => boolean;
+    navigate?: (url: string) => void;
+    onDateClick: (info: {
+        date: string;
+        time: string | null;
+        allDay: boolean;
+    }) => void;
+    onRange: (state: RangeState) => void;
+    onLoading: (loading: boolean) => void;
+}
+export interface CalendarEngine {
+    setView(view: ViewName): void;
+    gotoDate(day: string): void;
+    next(): void;
+    prev(): void;
+    today(): void;
+    refetch(): void;
+    setFirstDay(day: number): void;
+    setTimeZone(timeZone: string): void;
+    resize(): void;
+    state(): RangeState | null;
+    hasDay(day: string): boolean;
+    setCursor(day: string | undefined): boolean;
+    labelDays(label: (day: string) => string, fallback: string): void;
+    focusDay(day: string): boolean;
+    dispose(): void;
+}
+export declare const isViewName: (value: string | undefined) => value is ViewName;
+/**
+ * Draw a calendar in `container`.
+ *
+ * @param container Where the calendar goes.
+ * @param options
+ * @param options.view The first view.
+ * @param options.date The day to open on (`YYYY-MM-DD` in that zone); today when omitted.
+ * @param options.timeZone IANA zone the dates of the calendar are in; India Standard Time when omitted.
+ * @param options.firstDay The weekday a week starts on, 0 = Sunday to 6 = Saturday.
+ * @param options.emptyText What a list of no events says.
+ * @param options.fetchEvents Normalized events for the range (days; `end` is the first day not shown) and the view it is shown in.
+ * @param options.onEventClick Return true to stop the event's own link.
+ * @param options.navigate Called to open the link of a stacked event; defaults to window.location.assign.
+ * @param options.onDateClick
+ * @param options.onRange The visible period changed.
+ * @param options.onLoading
+ */
+export declare function mountCalendar(container: HTMLElement, options: MountOptions): CalendarEngine;
+export {};

package/types/calendarMath.d.ts

@@ -0,0 +1,40 @@
+export declare const MONTHS: string[];
+export declare const WEEKDAYS: string[];
+/**
+ * The weekday a calendar's week starts on, 0 = Sunday to 6 = Saturday: the element's own
+ * `first-day` attribute, else the theme's `--wui-first-day` token (inherited, so a product, a
+ * page or a section sets it once), else Monday.
+ */
+export declare const firstWeekday: (el: Element) => number;
+/** Pad a number to two digits for use in ISO date strings. */
+export declare const pad: (n: number) => string;
+/** Format a date as an ISO 8601 yyyy-mm-dd string. */
+export declare const toIso: (y: number, m: number, d: number) => string;
+/**
+ * Parse an ISO 8601 yyyy-mm-dd string into { y, m, d }.
+ * Month is 0-indexed (0 = January).
+ * Returns null if the string is invalid or falsy.
+ */
+export declare const parseIso: (s: string | null | undefined) => {
+    y: number;
+    m: number;
+    d: number;
+} | null;
+export declare const DISPLAY_FORMAT = "dd-MMM-yyyy";
+/**
+ * Format an ISO date string as a human-readable label. `format` is built from the tokens
+ * yyyy, MMMM, MMM, MM, dd and d; anything else is kept as written. The default is the Webority
+ * date format "dd-MMM-yyyy" (e.g., "04-Aug-2026").
+ * Returns an empty string if the ISO string is invalid.
+ */
+export declare const fmt: (iso: string | null | undefined, format?: string | null) => string;
+/** Return the number of days in the given (y, m) pair. Month is 0-indexed. */
+export declare const daysIn: (y: number, m: number) => number;
+/**
+ * Normalize an out-of-range month back into a valid (y, m) pair.
+ * Months < 0 roll back into the previous year(s); months > 11 roll forward.
+ */
+export declare const clampMonth: (y: number, m: number) => {
+    y: number;
+    m: number;
+};

package/types/calendarModel.d.ts

@@ -0,0 +1,78 @@
+export declare const CALENDAR_VIEWS: string[];
+export declare const CALENDAR_TONES: string[];
+/** Below this width of the element itself, a calendar that was given no view opens as a list. */
+export declare const NARROW_PX = 576;
+/**
+ * A date or date-time as a wall-clock string in `timeZone`: `YYYY-MM-DD` for a day, `YYYY-MM-DDTHH:mm:ss`
+ * for a moment. Takes those two forms, an ISO instant (`Z` or an offset) and epoch milliseconds.
+ * A day and a date-time with no offset are already wall-clock times and come back as written. Returns
+ * null for anything else.
+ */
+export declare function toWallClock(value: unknown, timeZone?: string): string | null;
+/** Whether `value` is a real `YYYY-MM-DD` day. */
+export declare const isIsoDate: (value: unknown) => boolean;
+/** The day `days` after `iso` (before, when negative). */
+export declare const addDays: (iso: string, days: number) => string;
+/** The same day-of-month `months` later, held to the last day of a shorter month. */
+export declare function addMonths(iso: string, months: number): string;
+/** The first day of the week holding `iso`, for weeks that start on `firstDay` (0 = Sunday, 1 = Monday). */
+export declare function weekStart(iso: string, firstDay?: number): string;
+/** `Sunday, 4 October 2026`, for a screen reader. */
+export declare function longDate(iso: string): string;
+/** `10:30 am` from `HH:mm` or `HH:mm:ss`. */
+export declare function clockTime(time: string): string;
+/**
+ * The day a key moves to from `iso` in `view`, or null when the key does nothing there. Arrows
+ * step a day (a week up or down in the month), Home and End go to the first and last day of the
+ * week (weeks start on `firstDay`, 0 = Sunday, 1 = Monday), Page Up and Page Down to the previous
+ * and next month (week, in a week view; day, in a day view).
+ */
+export declare function stepDate(iso: string, key: string, view: string | null, firstDay?: number): string | null;
+/** The keys `stepDate` can answer for. */
+export declare const STEP_KEYS: string[];
+/**
+ * The URL an events endpoint is asked: `start` and `end` as `YYYY-MM-DD` days in the calendar's zone, `end` being the
+ * first day not shown (the same convention as a half-open range), and, when given, `view` (month,
+ * week, day or list). Existing query parameters stay.
+ */
+export declare function eventsUrl(base: string, start: string, end: string, view?: string): string;
+/** Only web and mail links, and relative ones, become an event's link. */
+export declare function isSafeUrl(value: unknown): value is string;
+/** Warn once when `value` is outside `allowed`; nullish means omitted and passes. */
+export declare function checkValue(name: string, value: unknown, allowed: readonly unknown[]): void;
+export interface CalendarStack {
+    count: number;
+    url: string;
+    label: string;
+}
+export type CalendarWireEvent = Record<string, unknown>;
+export interface CalendarEvent {
+    id: string | null;
+    title: string;
+    start: string;
+    end: string | null;
+    allDay: boolean;
+    tone: string;
+    url: string | null;
+    stack: CalendarStack | null;
+    raw: CalendarWireEvent;
+}
+export type NormalizeEventResult = {
+    event: CalendarEvent;
+    problem?: undefined;
+} | {
+    event?: undefined;
+    problem: string;
+};
+/**
+ * One wire event ({ id, title, start, end, allDay, tone, url, stack }) in the form the calendar draws:
+ * dates as wall-clock strings in `timeZone`, `raw` being the event exactly as it was given (it comes back in
+ * the click event). Returns { event } or { problem } (a sentence naming what is wrong).
+ */
+export declare function normalizeEvent(raw: unknown, timeZone?: string): NormalizeEventResult;
+/** Normalize a list of wire events, reporting each one that cannot be drawn and drawing the rest. */
+export declare function normalizeEvents(list: unknown, timeZone?: string): CalendarEvent[];
+/** The label a screen reader hears for an event. */
+export declare function eventLabel(event: CalendarEvent): string;
+/** The detail of `wui-calendar:event-click`: the event as it was given. */
+export declare const eventDetail: (event: CalendarEvent) => CalendarWireEvent;

package/types/chart.d.ts

@@ -0,0 +1,4 @@
+import { WuiChart } from "./WuiChart.ts";
+export { CHART_STATES, CHART_TYPES, CHART_VIEWS, MAX_SERIES, MAX_SLICES, normalizeSpec, RENDERERS, STACK_MODES, X_KINDS, } from "./chartSpec.ts";
+export { formatValue } from "./formatters.ts";
+export { WuiChart };