@webority/ui-elements 0.149.0 → 0.150.0

package/types/kanban.d.ts

@@ -0,0 +1,157 @@
+import { ElementBase } from "./elementBase.ts";
+import { type SummaryFormat } from "./kanbanModel.ts";
+interface Verdict {
+    ok: boolean;
+    source?: boolean;
+    reason: string | null;
+}
+interface MoveDetail {
+    key: string | null;
+    card: HTMLElement;
+    from: string | null;
+    to: string | null;
+    index: number;
+}
+interface Snapshot {
+    parent: Node | null;
+    next: Node | null;
+    column: Element;
+    revealed: boolean;
+}
+interface PressState {
+    card: HTMLElement;
+    id: number;
+    x: number;
+    y: number;
+    type: string;
+    timer: ReturnType<typeof setTimeout> | 0;
+}
+interface DragState {
+    card: HTMLElement;
+    from: string | null;
+    ghost: HTMLElement;
+    dx: number;
+    dy: number;
+    x: number;
+    y: number;
+    over: HTMLElement | null;
+    verdicts: Map<string | null, Verdict>;
+}
+interface KeyboardLift {
+    card: HTMLElement;
+    from: string | null;
+    target: number;
+    verdicts: Map<string | null, Verdict>;
+}
+export declare class WuiKanban extends ElementBase {
+    accept?: (card: HTMLElement, from: string | null, to: string | null) => boolean | string | undefined;
+    _wired: boolean;
+    _filter: ((card: HTMLElement) => boolean) | null;
+    _expanded: Set<string | null>;
+    _revealed: Set<string | null>;
+    _press: PressState | null;
+    _drag: DragState | null;
+    _kbd: KeyboardLift | null;
+    _suppressClick: boolean;
+    _observer: MutationObserver | null;
+    _refreshQueued: boolean;
+    _scrollTimer: ReturnType<typeof setTimeout> | 0;
+    _onPointerMove: (e: PointerEvent) => void;
+    _onPointerUp: (e: PointerEvent) => void;
+    _onPointerCancel: () => void;
+    _onDocKeyDown: (e: KeyboardEvent) => void;
+    _onScroll: () => void;
+    constructor();
+    /** True when the host owns the cards (React): the element reports moves and never makes them. */
+    _controlled(): boolean;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** Show only the cards for which `fn(card)` returns true; null shows every card. */
+    setFilter(fn: ((card: HTMLElement) => boolean) | null): void;
+    /**
+     * Recount every column, recompute summaries and empty states, re-apply the filter and each
+     * column's visible-card cap.
+     */
+    refresh(): void;
+    /**
+     * Move a card by key to a column, through the same rules and persistence as a drop. Resolves
+     * true when the move was made (and saved, in server mode), false when it was refused or failed.
+     */
+    moveCard(key: string, toKey: string, index?: number): Promise<boolean>;
+    _columns(): HTMLElement[];
+    _columnByKey(key: string | null): HTMLElement | null;
+    _columnOf(card: Element): HTMLElement | null;
+    _titleOf(column: Element): string;
+    _bodyOf(column: Element): HTMLElement | null;
+    _cardsIn(column: Element): HTMLElement[];
+    _visibleCardsIn(column: Element): HTMLElement[];
+    _allCards(): HTMLElement[];
+    _cardByKey(key: string | null): HTMLElement | null;
+    _countsOf(column: Element): Element[];
+    _scroller(): HTMLElement | null;
+    _summaryFormat(): SummaryFormat | null;
+    _queueRefresh(): void;
+    _prepareCard(card: HTMLElement): void;
+    _announce(message: string | null | undefined): void;
+    _fire(type: string, detail: unknown, cancelable?: boolean): boolean;
+    /** Whether a card may leave its column at all; announces why not. */
+    _canLift(card: HTMLElement): boolean;
+    /** `{ ok, reason }` for a move of `card` from `fromKey` into the column `toKey`. */
+    _check(card: HTMLElement, fromKey: string | null, toKey: string | null): Verdict;
+    _markTargets(card: HTMLElement, fromKey: string | null): Map<string | null, Verdict>;
+    _clearTargets(): void;
+    /**
+     * Make (or, in controlled mode, request) a move already known to be allowed by the marks, or
+     * check it here for a programmatic move. Resolves true once the move stands.
+     */
+    _commit(card: HTMLElement, toKey: string | null, index?: number): Promise<boolean>;
+    _runStep(card: HTMLElement, detail: MoveDetail, snapshot: Snapshot, url: string, size: string | null): Promise<boolean>;
+    _lock(card: HTMLElement, on: boolean): void;
+    _rollback(card: HTMLElement, snapshot: Snapshot): void;
+    /**
+     * Apply a server fragment: every `[data-wui-card]` in it replaces the card with the same key
+     * where it stands, and every `template[data-wui-kanban-summary="col"]` becomes that column's
+     * summary. Returns the fresh element of the first card replaced, or null.
+     */
+    _applyFragment(html: string): HTMLElement | null;
+    _refocusSoon(key: string | null): void;
+    /** Focus a card a keyboard move just placed, scrolled into view inside its column's own scroll. */
+    _focusMoved(card: HTMLElement): void;
+    _pointerDown(e: PointerEvent): void;
+    _pointerMove(e: PointerEvent): void;
+    _pointerUp(e: PointerEvent): void;
+    _startDrag(press: PressState, x: number, y: number): void;
+    _dragTo(x: number, y: number): void;
+    /** The column under a viewport point, by layout boxes (the ghost never gets in the way). */
+    _columnAt(x: number, y: number): HTMLElement | null;
+    /** Where in `column` a drop at viewport height `y` lands, counted over its visible cards. */
+    _indexAt(column: HTMLElement, y: number): number;
+    _autoScroll(x: number, y: number, over: HTMLElement | null): void;
+    /**
+     * Scroll a column's card list one step when `y` is near its top or bottom edge and the list
+     * can still move that way. True when it scrolled. A list that does not overflow (any board
+     * without `fill`) never scrolls here.
+     */
+    _scrollColumn(column: HTMLElement, y: number): boolean;
+    _endPointer(drop: boolean): void;
+    _click(e: MouseEvent): void;
+    _keyDown(e: KeyboardEvent): void;
+    _liftedKey(e: KeyboardEvent, kbd: KeyboardLift): void;
+    _endKeyboard(): void;
+    _restoreCollapsed(): void;
+    _setCollapsed(column: HTMLElement, collapsed: boolean | undefined, remember: boolean): void;
+    /** "Show N more" opens the column; "Show fewer" puts the cap back, dropped cards included. */
+    _toggleMore(column: HTMLElement | null): void;
+    /** Cards a server-paged column holds past the ones on the page; 0 for any other column. */
+    _unloadedIn(column: HTMLElement): number;
+    /**
+     * Fetch the next cards of a server-paged column and append those the board does not hold yet.
+     * A failed load leaves the column as it was and says so in a toast.
+     */
+    _loadMore(column: HTMLElement | null): Promise<void>;
+    _loadOnScroll(target: Element): void;
+    _isPhone(): boolean;
+    _showColumn(key: string | null, scroll?: boolean): void;
+    _syncSwitcherFromScroll(): void;
+}
+export {};

package/types/kanbanModel.d.ts

@@ -0,0 +1,77 @@
+/** Column tones (the dot beside a column title). */
+export declare const KANBAN_TONES: readonly string[];
+/** Formats a column summary can be computed in: the sum of the visible cards' values. */
+export declare const KANBAN_SUMMARY_FORMATS: readonly string[];
+/** localStorage key prefix of a board's remembered collapsed columns. */
+export declare const KANBAN_STORAGE_PREFIX = "wui-kanban:";
+/** Below this width the board shows one column per screen with a switcher. */
+export declare const KANBAN_PHONE_QUERY = "(max-width: 767.98px)";
+/** How long a finger rests on a card before it lifts (a shorter touch is a scroll). */
+export declare const KANBAN_LONG_PRESS_MS = 400;
+/** How far a mouse or pen moves before a press becomes a drag. */
+export declare const KANBAN_DRAG_THRESHOLD_PX = 6;
+/** The words the board says on its own. */
+export declare const KANBAN_TEXT: Readonly<{
+    help: "Press Space to pick up the card. Use the Left and Right arrow keys to choose a column, then Space to drop it, or Escape to cancel.";
+    empty: "Nothing here";
+    collapse: (column: string) => string;
+    expand: (column: string) => string;
+    lifted: (card: string, column: string) => string;
+    over: (column: string, count: number) => string;
+    overSource: (column: string) => string;
+    overRefused: (column: string, reason: string) => string;
+    dropHere: (card: string, column: string) => string;
+    refused: (from: string, to: string) => string;
+    moved: (card: string, column: string) => string;
+    saving: (card: string, column: string) => string;
+    cancelled: (card: string) => string;
+    rolledBack: (card: string, column: string) => string;
+    locked: (card: string) => string;
+    more: (count: number) => string;
+    fewer: "Show fewer";
+    loadMore: (n: number) => string;
+    loading: "Loading…";
+    loadFailed: "More cards could not be loaded. Try again.";
+    swipeHint: "Swipe sideways or tap a column";
+    busy: "This card is still saving. Try again in a moment.";
+    failed: Readonly<{
+        forbidden: "You do not have permission to move this card.";
+        client: "This card could not be moved. Refresh the board and try again.";
+        validation: "This card could not be moved. Refresh the board and try again.";
+        server: "Something went wrong on our side, so the card went back. Try again in a moment.";
+        network: "Could not reach the server, so the card went back. Check your connection and try again.";
+    }>;
+}>;
+export interface SummaryFormat {
+    style: string;
+    currency?: string;
+    unit?: string;
+    decimals?: number;
+}
+/**
+ * A column's visible-card cap from its attribute or prop: null when unset, else a whole number of
+ * 1 or more. Throws on anything else: a wrong cap is the caller's bug, never guessed at.
+ */
+export declare function kanbanVisibleLimit(value: unknown): number | null;
+/**
+ * Which of a column's shown cards wait behind its "Show N more" button. `keys` are the cards the
+ * filter lets through, in order; the first `limit` show, and so does every key in `revealed`
+ * (cards just dropped there), on top of the cap. Returns the set of keys held back; empty when
+ * there is no cap or the column is expanded.
+ */
+export declare function kanbanOverflow(keys: readonly (string | null)[], limit: number | null, expanded: boolean, revealed: ReadonlySet<string | null>): Set<string | null>;
+/** Name of a card for announcements: its aria-label, else its text, trimmed. */
+export declare function kanbanCardLabel(card: Element): string;
+/** The storage key of a board's remembered state, or null when the board has no id. */
+export declare function kanbanStorageKey(boardId: string | null | undefined): string | null;
+/** Read the remembered collapsed state: `{ [columnKey]: boolean }`, empty when nothing is stored. */
+export declare function readKanbanCollapsed(boardId: string | null | undefined, storage?: Storage | undefined): Record<string, boolean>;
+/** Remember one column's collapsed state; other columns keep theirs. */
+export declare function writeKanbanCollapsed(boardId: string | null | undefined, columnKey: string | null, collapsed: boolean | undefined, storage?: Storage | undefined): void;
+/**
+ * The format object `formatValue` takes for a computed summary. Throws on a value outside the
+ * vocabulary: a wrong format is the caller's bug, never mapped to a right one.
+ */
+export declare function kanbanSummaryFormat(format: string, unit?: string | null): SummaryFormat;
+/** Sum of numeric values, ignoring blanks and anything that is not a finite number. */
+export declare function sumKanbanValues(values: readonly unknown[]): number;

package/types/leadPopupGlobal.d.ts

@@ -0,0 +1 @@
+export {};

package/types/leadPopupStandalone.d.ts

@@ -0,0 +1,2 @@
+export declare const THEME_DEFAULTS: Record<string, string>;
+export declare const LEAD_POPUP_CSS: string;

package/types/listQuery.d.ts

@@ -0,0 +1,87 @@
+export type SortOrder = "asc" | "desc";
+export type FacetType = "enum" | "multiEnum" | "dateRange" | "text";
+export interface ListFacet {
+    key: string;
+    type: FacetType;
+}
+type FilterScalar = string | number | boolean | Date | null | undefined;
+export type FacetValue = FilterScalar | FilterScalar[] | {
+    from?: FilterScalar;
+    to?: FilterScalar;
+};
+export interface BuildListQueryOptions {
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortOrder?: unknown;
+    search?: string;
+    filters?: Record<string, FacetValue>;
+}
+export interface ListQueryDefaults {
+    page?: number;
+    pageSize?: number;
+    sortBy?: string;
+    sortOrder?: SortOrder;
+    filters?: Record<string, FacetValue>;
+}
+export interface ParseListQueryOptions {
+    facets?: ListFacet[];
+    defaults?: ListQueryDefaults;
+}
+export interface ParsedListQuery {
+    page: number;
+    pageSize: number | undefined;
+    sortBy: string | undefined;
+    sortOrder: SortOrder;
+    search: string;
+    filters: Record<string, FacetValue>;
+}
+/** The list-query params the table itself owns; every other param is a filter. */
+export declare const LIST_QUERY_RESERVED: readonly string[];
+/** The filter param a search box writes (Webority.Ui.Razor ListQuery.SearchKey). */
+export declare const SEARCH_PARAM = "search";
+/**
+ * Builds the flat query string for one page of a list.
+ *
+ * A filter value is a scalar, an array (one param per item) or a date range `{ from, to }`
+ * (written as `<name>From` / `<name>To`). Empty values are left out. A `Date` is written as
+ * yyyy-MM-dd.
+ *
+ * @param [query]
+ * @param [query.page] 1-based.
+ * @param [query.pageSize]
+ * @param [query.sortBy]
+ * @param [query.sortOrder='asc'] Written only with `sortBy`.
+ * @param [query.search] Free text, trimmed, written as the `search` param and left out when blank.
+ * @param [query.filters]
+ * @throws When a filter is named page, pageSize, sortBy, sortOrder or search, or `sortOrder` is not asc or desc.
+ */
+export declare function buildListQuery({ page, pageSize, sortBy, sortOrder, search, filters }?: BuildListQueryOptions): URLSearchParams;
+/** The empty value of a facet: "" (enum, text), [] (multiEnum) or { from: "", to: "" } (dateRange). */
+export declare function emptyFacetValue(facet: Pick<ListFacet, "type">): string | string[] | {
+    from: string;
+    to: string;
+};
+/** True when a facet's value narrows the list. */
+export declare function isFacetActive(facet: Pick<ListFacet, "type">, value: FacetValue): boolean;
+/** Every query param name a list owns: the reserved five plus each facet's own (`<key>From`/`<key>To` for a date range). */
+export declare function listQueryParamNames(facets?: readonly ListFacet[]): Set<string>;
+/**
+ * Reads a list query back out of the URL's search params: the inverse of `buildListQuery`.
+ * Anything missing or invalid falls back to `defaults`. Every facet gets a value, empty when the
+ * URL has none, so the result is always safe to render.
+ *
+ * `defaults.filters` apply only when the URL carries no list param at all (the first landing on
+ * the page). After that the URL is the truth, so clearing a filter that has a default stays cleared.
+ *
+ * `search` is read from the URL only: trimmed, and empty when the URL has none. `pageSize` is
+ * undefined when neither the URL nor `defaults.pageSize` names one, so the request omits it and
+ * the server default applies.
+ *
+ * @param searchParams
+ * @param [options]
+ * @param [options.facets]
+ * @param [options.defaults]
+ */
+export declare function parseListQuery(searchParams: URLSearchParams | string, { facets, defaults }?: ParseListQueryOptions): ParsedListQuery;
+export {};

package/types/listboxKeyNav.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Shared keyboard-navigation handler for listbox controls (select, autocomplete, multiselect).
+ * Encapsulates the common pattern: cursor movement (arrows, home/end, page up/down), typeahead
+ * buffer + 500ms clear, and Escape dismissal. Behavior that differs per control (what Enter does,
+ * what Escape does beyond close) is passed as callbacks.
+ *
+ * **Invariant:** The `visible()` callback and the `setActive()` mechanism must already exist on
+ * the caller's instance; this module provides only the keydown handler and typeahead management.
+ *
+ * **Signature:**
+ * ```
+ * const handler = createListboxKeyNav({
+ *   getVisibleOptions: () => [...non-hidden option elements],
+ *   getActive: () => this._active,
+ *   setActive: (i) => { ... },
+ *   onEnter: (activeOption, opts) => { ... }, // fired when Enter pressed & active option exists
+ *   onEscape: () => { ... },                   // fired when Escape pressed
+ *   onTypeahead: (char) => { ... },            // optional: invoked for printable keys outside input
+ *   typeaheadMs: 500,                          // optional: buffer clear timeout (default 500)
+ * });
+ * // Then bind: element.addEventListener('keydown', handler);
+ * // On unmount: handler.teardown();
+ * ```
+ *
+ * **Key contract:** setActive(-1) on close and on Escape is the caller's responsibility
+ * (or part of onEscape). This module manages the cursor AND the typeahead buffer lifecycle,
+ * but does NOT know how to open/close, those are element-specific (control button, menu div).
+ */
+export interface ListboxKeyNavConfig {
+    getVisibleOptions: () => HTMLElement[];
+    getActive: () => number;
+    setActive: (index: number) => void;
+    onEnter?: (activeOption: HTMLElement | undefined, visibleOptions: HTMLElement[]) => void;
+    onEscape?: () => void;
+    onTypeahead?: (char: string, activeIndex: number, visibleOptions: HTMLElement[]) => void;
+    typeaheadMs?: number;
+}
+export interface ListboxKeyNav {
+    handler: (e: KeyboardEvent) => void;
+    clearTypeahead: () => void;
+    teardown: () => void;
+}
+/**
+ * Factory: creates a keydown handler + typeahead management for a listbox.
+ * @param config
+ * @param config.getVisibleOptions - returns array of currently visible option elements
+ * @param config.getActive - returns current active index
+ * @param config.setActive - (index) => void, sets the active cursor
+ * @param [config.onEnter] - (activeOption, visibleOptions) => void, Enter key action
+ * @param [config.onEscape] - () => void, Escape key action (may include close + teardown)
+ * @param [config.onTypeahead] - (char, activeIndex, visibleOptions) => void, char matched to option
+ * @param [config.typeaheadMs] - clear buffer timeout (default 500)
+ * @returns { handler: (KeyboardEvent) => void, teardown: () => void, clearTypeahead: () => void }
+ */
+export declare function createListboxKeyNav(config: ListboxKeyNavConfig): ListboxKeyNav;
+/**
+ * Moves the `is-active` highlight inside `container` to `next` (null clears it), touching only the
+ * row that had it and the row that gets it. A pointer moving through a long list calls this many
+ * times a second, so it must not walk every option.
+ * @param container the element holding the option rows
+ * @param next the row to highlight
+ */
+export declare function moveActiveRow(container: Element, next: Element | null): void;

package/types/mentionText.d.ts

@@ -0,0 +1,45 @@
+/** An id a mention may carry: an opaque public id, never markup. */
+export declare const MENTION_ID_PATTERN: RegExp;
+export type MentionPart = {
+    text: string;
+} | {
+    id: string;
+    label: string;
+};
+export interface MentionSpan {
+    start: number;
+    end: number;
+    id: string;
+    label: string;
+}
+/** The label as a token can hold it: no brackets or line breaks, trimmed, at most 100 characters. */
+export declare function mentionLabel(label: unknown): string;
+/**
+ * Split a stored value into what reads as text and the people it mentions.
+ * @param value
+ * @returns In order; adjacent text is joined.
+ */
+export declare function parseMentionValue(value: string): MentionPart[];
+/**
+ * What a value reads as in a text box, with where each mention sits in it.
+ * @param value
+ * @returns The text and the mention spans in it.
+ */
+export declare function mentionTextFromValue(value: string): {
+    text: string;
+    mentions: MentionSpan[];
+};
+/**
+ * The stored value for text and the mentions placed in it. A mention whose span no longer reads
+ * "@Label" is dropped and its text kept as typed.
+ * @param text
+ * @param mentions
+ * @returns
+ */
+export declare function mentionValueFromText(text: string, mentions?: MentionSpan[]): string;
+/**
+ * The ids a value mentions, each once, in the order first mentioned.
+ * @param value
+ * @returns
+ */
+export declare function mentionedIds(value: string): string[];

package/types/navReveal.d.ts

@@ -0,0 +1 @@
+export declare function revealActiveNavItem(scroller: HTMLElement | null | undefined): void;

package/types/notificationDays.d.ts

@@ -0,0 +1,50 @@
+/** A count above this shows as "99+". */
+export declare const NOTIFICATION_COUNT_CAP = 99;
+export type NotificationTime = string | number | Date;
+export interface DatedNotification {
+    id: string;
+    at: NotificationTime;
+}
+export interface NotificationDayGroup<T extends DatedNotification> {
+    key: string;
+    heading: string;
+    items: T[];
+}
+/** The words the centre says on its own. */
+export declare const NOTIFICATION_TEXT: Readonly<{
+    label: "Notifications";
+    empty: "You are all caught up.";
+    markAll: "Mark all read";
+    viewAll: "View all";
+    unreadPrefix: "Unread: ";
+    today: "Today";
+    yesterday: "Yesterday";
+    allRead: "All notifications marked as read.";
+    noneUnread: "No unread notifications";
+    failed: Readonly<{
+        forbidden: "You do not have permission to mark these as read.";
+        client: "These could not be marked as read. Refresh the page and try again.";
+        validation: "These could not be marked as read. Refresh the page and try again.";
+        server: "Something went wrong on our side, so these were not marked as read. Try again in a moment.";
+        network: "Could not reach the server, so these were not marked as read. Check your connection and try again.";
+    }>;
+}>;
+/** "99+" above the cap, otherwise the number. */
+export declare function notificationCountText(unread: number): string;
+/** The bell's name: the badge is hidden from assistive tech, so the name carries the count. */
+export declare function notificationTriggerLabel(label: string, unread: number): string;
+/** What a screen reader hears when the count changes. */
+export declare function notificationUnreadAnnouncement(unread: number): string;
+/** The IST time of day an item shows, 14:05. A bare day has none: read as midnight IST it would show 00:00. */
+export declare function notificationTime(at: string): string;
+/** "Today", "Yesterday" or the date (04-Oct-2026) of an instant, by India's calendar days. */
+export declare function notificationDayHeading(at: NotificationTime, now?: NotificationTime): string;
+/**
+ * Items grouped by India's calendar day of `at`, in the order each day first appears (newest first
+ * in, newest first out). A group is `{ key, heading, items }`; `key` is the date and is stable
+ * across the day, `heading` is Today, Yesterday or the date.
+ *
+ * @param items
+ * @param [now] The clock for Today and Yesterday; defaults to the time of the call.
+ */
+export declare function groupNotificationsByDay<T extends DatedNotification>(items: T[], now?: NotificationTime): NotificationDayGroup<T>[];

package/types/optionLabel.d.ts

@@ -0,0 +1,27 @@
+/** Set by _snapshotDeclared() on options read from author-written <wui-option> children, and by withTrustedLabel(). */
+export declare const TRUSTED_HTML: unique symbol;
+export interface SelectOptionLabel {
+    label?: unknown;
+    icon?: unknown;
+    flag?: unknown;
+    value?: unknown;
+    [TRUSTED_HTML]?: boolean;
+}
+/**
+ * A copy of the option whose label is markup to render as-is. Only for markup a wrapper
+ * rendered itself from author code (a React node label); never for option data from a request.
+ */
+export declare const withTrustedLabel: <T extends SelectOptionLabel>(o: T) => T;
+declare const escapeHtml: (v: unknown) => string;
+/** HTML for an option's label. Author markup passes through; everything else is escaped. */
+export declare const optionLabelHtml: (o: SelectOptionLabel | null | undefined) => string;
+/** Drops tags from a plain string. Entities are left as written; use optionText for a trusted label. */
+export declare const stripTags: (html: unknown) => string;
+/**
+ * The visible text of an option's label: display text after a pick, search matching and
+ * accessible names. A trusted label is markup, so its entities (&nbsp; &amp;) are decoded
+ * through an inert template, the way WuiSelect reads textContent; any other label is data
+ * and keeps the tag strip. Cached per option, since a search runs this on every keystroke.
+ */
+export declare const optionText: (o: SelectOptionLabel | null | undefined) => string;
+export { escapeHtml };

package/types/overlayRelease.d.ts

@@ -0,0 +1,12 @@
+export interface OverlayInstance {
+    tip?: Element | null;
+    hide(): void;
+    dispose(): void;
+}
+/** Bootstrap's Tooltip or Popover class: its event namespace and its instance lookup. */
+export interface OverlayComponent {
+    readonly EVENT_KEY: string;
+    getInstance(element: Element): OverlayInstance | null;
+}
+/** Dispose the `kind` (Tooltip or Popover) instance on `el` without cutting its hide transition short. */
+export declare function releaseOverlay(kind: OverlayComponent, el: Element): void;

package/types/pageBarBulk.d.ts

@@ -0,0 +1,4 @@
+export declare const BAR_BULK_IN_BAR_ATTRIBUTE: string;
+export declare function barBulkCountText(n: number): string;
+export declare function applyBarBulk(header: HTMLElement, selected: number): void;
+export declare function initPageBarBulk(root?: ParentNode): void;

package/types/passwordRules.d.ts

@@ -0,0 +1,50 @@
+export interface CustomPasswordRule {
+    label: string;
+    pattern: string;
+}
+export interface PasswordRules {
+    minLength: number;
+    uppercase: boolean;
+    lowercase: boolean;
+    digit: boolean;
+    special: boolean;
+    uniqueChars: number;
+    customRules: ReadonlyArray<CustomPasswordRule>;
+}
+export type PasswordRuleOptions = true | Partial<PasswordRules> | null | undefined;
+export interface PasswordRule {
+    key: string;
+    label: string;
+    test: (value: string) => boolean;
+}
+export interface PasswordRuleResult {
+    key: string;
+    label: string;
+    met: boolean;
+}
+/** The default policy. A product whose server accepts fewer characters sets `minLength` itself. */
+export declare const DEFAULT_PASSWORD_RULES: PasswordRules;
+/** Popover heading, so both surfaces read the same. */
+export declare const DEFAULT_REQUIREMENTS_TITLE: string;
+/**
+ * Build the ordered rule list from an options object. Each rule is `{ key, label, test }`.
+ * A rule is included only when its option is on (a positive `minLength`/`uniqueChars`, a truthy
+ * boolean), so a host that does not require, say, a special character simply omits that line.
+ *
+ * `customRules` is a list of `{ label, pattern }`: a product's own rule, ticked when the regular
+ * expression `pattern` (a JavaScript RegExp source string, e.g. `"^\\S*$"` for no spaces) matches the
+ * password. They follow the built-in rules, keyed `custom-0`, `custom-1`, and so on.
+ *
+ * @param options `true` for the defaults, or an override object.
+ */
+export declare function buildPasswordRules(options?: PasswordRuleOptions): PasswordRule[];
+/**
+ * Evaluate a password against the built rules. Returns `[{ key, label, met }]` in rule order,
+ * the exact shape both the React list and the Razor JS list render from.
+ *
+ * @param password
+ * @param options `true` for the defaults, or an override object.
+ */
+export declare function evaluatePassword(password: unknown, options?: PasswordRuleOptions): PasswordRuleResult[];
+/** True only when every rule is met: a cheap "is this password strong enough yet?" for callers. */
+export declare function passwordSatisfies(password: unknown, options?: PasswordRuleOptions): boolean;

package/types/phoneData.d.ts

@@ -0,0 +1 @@
+export {};

package/types/phoneLib.d.ts

@@ -0,0 +1,15 @@
+import type * as LibPhone from "libphonenumber-js/max";
+export type PhoneCore = Pick<typeof LibPhone, "AsYouType" | "getExampleNumber" | "isSupportedCountry" | "isValidPhoneNumber" | "parsePhoneNumber">;
+export type PhoneExamples = Parameters<typeof LibPhone.getExampleNumber>[1];
+/** The slice of libphonenumber-js <wui-phone> calls, in one shape for both builds. */
+export interface PhoneLib extends PhoneCore {
+    examples: PhoneExamples;
+}
+declare global {
+    interface Window {
+        WeborityPhone?: PhoneLib;
+    }
+}
+export declare function importPhoneLib(): Promise<PhoneLib>;
+/** The slice of libphonenumber-js <wui-phone> calls, in one shape for both builds. */
+export declare function phoneLib(core: PhoneCore, examples: PhoneExamples): PhoneLib;

package/types/phoneLibGlobal.d.ts

@@ -0,0 +1,3 @@
+import type { PhoneLib } from "./phoneLib.ts";
+export declare const PHONE_SCRIPT: string;
+export declare function importPhoneLib(): Promise<PhoneLib>;

package/types/razor-js/modules/api.d.ts

@@ -0,0 +1,33 @@
+export type RemoteOptions = Parameters<typeof window.WeborityUiElements.loadRemoteModal>[1];
+export declare const modal: {
+    open: (id: string) => void;
+    close: (id: string) => void;
+    load: (url: string, options?: RemoteOptions) => Promise<import("../../server/remoteModal.ts").ModalHandle>;
+};
+export declare const drawer: {
+    load: (url: string, options?: RemoteOptions) => Promise<import("../../server/remoteModal.ts").ModalHandle>;
+};
+export declare const pane: {
+    load: (url: string, options?: RemoteOptions) => Promise<import("../../server/remoteModal.ts").ModalHandle>;
+    close: (target: string | Element) => void;
+};
+export interface TourSeenStore {
+    isSeen(tourId: string): Promise<boolean>;
+    markSeen(tourId: string, outcome: "finished" | "skipped"): Promise<void>;
+}
+export declare const tour: {
+    seenStore: TourSeenStore | null;
+    start: (id: string) => unknown;
+};
+export declare const table: {
+    get: (target: string | Element) => import("../../server/serverTable.ts").ServerTableHandle;
+};
+export declare const shell: {
+    get: (target?: string | Element) => import("../../server/shellParts.ts").ShellHandle;
+};
+export declare const filePicker: {
+    setLoading: (target: string | Element, on: boolean) => void;
+};
+export declare const unsaved: {
+    reset: (target: string | Element) => void;
+};

package/types/razor-js/modules/avatars.d.ts

@@ -0,0 +1 @@
+export declare const initAvatarPhotos: (root?: Document | Element) => void;

package/types/razor-js/modules/dropZones.d.ts

@@ -0,0 +1,2 @@
+export declare const initDropZones: (root?: Document | Element) => void;
+export declare const initFileAttachments: (root?: Document | Element) => void;