@mudlet/mudlet-web 0.5.0 → 1.0.1

package/dist-lib/ui/labels/LabelManager.d.ts

@@ -1,4 +1,5 @@
 import type { MoviePlayer } from './gifMovie';
+import { type LinkStyleState } from './labelModel';
 import { OverlayLayerOrder } from '../layout/overlayLayerOrder';
 export interface LabelCreateOptions {
     /** Parent window id ('main' for main viewport). Defaults to 'main'. */
@@ -43,9 +44,31 @@ export interface LabelState {
         url: string;
         width?: number;
         height?: number;
+        svg?: boolean;
     };
+    /** Mudlet setSvgTint / setSvgRotation / setSvgShear. Like TLabel's, these
+     *  belong to the label rather than to its SVG: they outlive a
+     *  resetBackgroundImage and a new image, and one set before any SVG arrives
+     *  applies the moment one does — only their own reset functions clear them.
+     *  The tint is a CSS colour painted over the SVG's opaque pixels
+     *  (CompositionMode_SourceIn); rotation is in degrees and the shear factors
+     *  are QTransform::shear's. */
+    svgTint?: string;
+    svgRotation?: number;
+    svgShearX?: number;
+    svgShearY?: number;
     /** Qt-style CSS string set via setLabelStyleSheet; parsed at render time. */
     styleSheet?: string;
+    /** Family set via `setFont(labelName, family)` — the widget font, which in
+     *  Qt is a property of the QLabel itself and so is kept here rather than
+     *  folded into `styleSheet`. A stylesheet `font-family` still wins over it
+     *  at render, as QSS wins over a widget font in Qt. Always stored as the
+     *  font database spells it (ScriptingAPI.resolveFontFamily), because
+     *  Geyser.Label:setFont reads it straight back through getFont(). */
+    fontFamily?: string;
+    /** Point size set via `setFontSize(labelName, size)` — the other half of
+     *  the widget font, kept and applied the same way as {@link fontFamily}. */
+    fontSize?: number;
     /** Sticky Qt `alignment` widget property, captured from a
      *  `qproperty-alignment` declaration in any setStyleSheet call. In Qt,
      *  qproperty-* declarations set the widget property permanently — a later
@@ -85,6 +108,10 @@ export interface LabelState {
      *  same reason (Qt won't style them either). Only populated while a visited
      *  color is set, as Mudlet does. */
     visitedLinks?: Set<string>;
+    /** What the last link-styling pass was given and made of it, so a styled
+     *  tag read back with getLabelText can be given back as it was written —
+     *  see labelModel.ts. */
+    linkText?: LinkStyleState;
     /** Click handler installed by setLabelClickCallback. The event table mirrors
      *  Mudlet's `mudlet.mouse_button` shape: `{button, x, y, alt, ctrl, shift, meta}`. */
     onClick?: (event: LabelMouseEvent) => void;
@@ -104,17 +131,37 @@ export interface LabelState {
     onMouseLeave?: (event: LabelMouseEvent) => void;
     /** Tooltip text rendered via the title attribute. */
     tooltip?: string;
+    /** Mudlet setLabelAccessibleName — the name a screen reader gives the
+     *  label. Empty means none of its own: TLabelModel::effectiveAccessibleName
+     *  then names it after the text it shows, or else its tooltip. */
+    accessibleName?: string;
+    /** Mudlet setLabelAccessibleRole — `true` for "button", `false` for "text",
+     *  unset for "" (decided by the label's click and release callbacks, as
+     *  TLabelModel::actsAsButton does). */
+    accessibleButton?: boolean;
+    /** Mudlet setLabelLiveRegion — how a change to the label's text is spoken
+     *  while the profile's `accessibleLabels` setting is on. Unset is "off". */
+    liveRegion?: LabelLiveRegion;
     /** CSS cursor value (e.g. 'pointer', 'crosshair', 'none'). */
     cursor?: string;
     /** Animated GIF player installed by Mudlet's setMovie. Rendered as a
      *  <canvas> instead of the html content (QLabel shows one or the other). */
     movie?: MoviePlayer;
+    /** A movie text has taken the place of: QLabel::setText drops the movie
+     *  from the label's display, but TLabel still owns the QMovie, so the
+     *  profile goes on counting it (getProfileStats().gifs) until setMovie
+     *  replaces it or the label is deleted. Nothing drives it any more. */
+    hiddenMovie?: MoviePlayer;
 }
 /** Event payload for label mouse callbacks. `button` is the Qt button *name*
  *  Mudlet reports ("LeftButton" / "RightButton" / "MidButton" / "NoButton" / …),
  *  so ported Geyser scripts that branch on `event.button == "LeftButton"` work. */
 export interface LabelMouseEvent {
     button: string;
+    /** Every button held while the event happened, as Qt button names in
+     *  Qt's bit order (Mudlet's `event.buttons`, a Lua list): `["LeftButton"]`
+     *  on a left press, empty on its release. */
+    buttons: string[];
     x: number;
     y: number;
     globalX: number;
@@ -125,23 +172,63 @@ export interface LabelMouseEvent {
     meta: boolean;
 }
 export interface LabelWheelEvent extends LabelMouseEvent {
-    /** Mudlet exposes wheel deltas via `angleDelta.x` / `angleDelta.y` (Qt naming). */
+    /** Mudlet's wheel deltas, flat on the event: `event.angleDeltaX` /
+     *  `event.angleDeltaY`, in Qt's eighths of a degree (±120 per notch). */
+    angleDeltaX: number;
+    angleDeltaY: number;
+    /** The same deltas nested, as Mudlet Web reported them before it matched
+     *  Mudlet's shape. Kept so scripts written against it keep working. */
     angleDelta: {
         x: number;
         y: number;
     };
 }
 type Listener = (labels: LabelState[]) => void;
+/** TLabelLiveRegion, by the name setLabelLiveRegion takes and getLabelLiveRegion gives. */
+export type LabelLiveRegion = 'off' | 'polite' | 'assertive';
+/** What getLabelAccessibleRole reports (Host::labelAccessibleRole). */
+export type LabelAccessibleRole = 'button' | 'graphic' | 'animation' | 'text';
+/** QTextDocumentFragment::fromHtml(html).toPlainText(), simplified — the text
+ *  TLabelModel's plainName() names a label after. A block or line break is a
+ *  break in Qt's plain text, so it parts the words on either side here too,
+ *  where textContent would run them together. */
+export declare function labelPlainName(html: string): string;
 /** Runs the action behind an `<a href>` clicked inside a label — installed by
  *  ScriptingAPI, which owns the send/prompt/openUrl/Lua machinery the schemes
  *  map onto (see {@link LabelManager.setLinkActivator}). */
 type LinkActivator = (href: string) => void;
+/** `html` with every `<…>` run dropped: from each `<` up to the next `>`, and
+ *  text after a `<` that never closes kept as is. The same string the regex
+ *  `/<[^>]*>/g` replace gave, as a scanner — only renderedText's no-DOM
+ *  fallback reads it, to decide whether a label is empty, and it never goes
+ *  back into HTML. Exported for tests. */
+export declare function stripTagsNoDom(html: string): string;
+/** The text `html` renders to, trimmed — QTextDocumentFragment::toPlainText
+ *  as TLabel::sizeHint reads it. Exported for tests. */
+export declare function renderedText(html: string): string;
+/** TLabelModel::actsAsButton: a role chosen for it, else whether it has a
+ *  click or release callback to press — never while clicks pass through it. */
+export declare function labelActsAsButton(lbl: Readonly<LabelState>): boolean;
+/** TLabelModel::effectiveAccessibleName. */
+export declare function effectiveAccessibleName(lbl: Readonly<LabelState>): string;
+/** Host::labelAccessibleRole: a button whatever it shows, else what it shows —
+ *  a movie is an animation, an image with no text over it a graphic
+ *  (TLabel::showsImage), anything else text. */
+export declare function accessibleRole(lbl: Readonly<LabelState>): LabelAccessibleRole;
 export declare class LabelManager {
     readonly overlayZ: OverlayLayerOrder;
+    /** Where a press or release a label has no callback for goes: TLabel hands
+     *  it to the window under the label (`parent`), which raises it as that
+     *  window's sysWindowMousePressEvent / ReleaseEvent. Wired by MudSession. */
+    onUnhandledMouse?: (kind: 'press' | 'release', parent: string, e: MouseEvent) => void;
     private readonly labels;
     private readonly byParent;
     private readonly listeners;
     private linkActivator;
+    /** The profile's `accessibleLabels` setting (Host::mAccessibleLabels): with it
+     *  on, a label that acts as a button takes keyboard focus and is pressed with
+     *  Space or Return, and a live region speaks its label's text changes. */
+    private accessibleLabelsOn;
     private indexAdd;
     private indexRemove;
     constructor(overlayZ?: OverlayLayerOrder);
@@ -159,19 +246,46 @@ export declare class LabelManager {
      *  ('main', a userwindow / miniconsole id, or a scroll box name). Both
      *  the old and the new parent's overlays re-render. */
     setParent(name: string, parent: string): boolean;
-    /** Mudlet `getLabelSizeHint(name)` → the label's preferred `{width,height}`.
-     *  Mudlet returns the QLabel sizeHint (the size its content wants); the
-     *  browser analogue is the rendered node's content extent
-     *  (`scrollWidth`/`scrollHeight`), read off the `data-mudix-label` element.
-     *  Falls back to the configured geometry when the label isn't in the DOM
-     *  yet (hidden, or rendered before mount). null when no such label. */
+    /** Mudlet `getLabelSizeHint(name)` → the label's preferred `{width,height}`:
+     *  TLabel::sizeHint, which is QLabel's — the extent of the label's contents
+     *  (its text laid out unwrapped, or its movie frame) plus the margin, border
+     *  and padding its stylesheet puts around them. It never depends on the box
+     *  the label has now, which is what lets Geyser's adjustSize/autoWidth grow a
+     *  label as well as shrink it. Falls back to the configured geometry only
+     *  where there is no layout to measure at all. null when no such label. */
     getSizeHint(name: string): {
         width: number;
         height: number;
     } | null;
+    /**
+     * TLabel::sizeHint for a label whose only content is an SVG background: the
+     * document's own size plus the chrome (stylesheet margin, border and
+     * padding) QLabel adds around its contents. QLabel's hint cannot see the
+     * SVG layer, and Geyser's autoAdjustSize() sizes a label from the hint. A
+     * label that does carry text or a movie keeps the ordinary hint, because
+     * the SVG scales to fit whatever that asks for. Geyser.Label:new always
+     * echoes an empty rich-text div, so "text" is what the HTML renders to, not
+     * whether the string is empty. Null when this is not that case.
+     */
+    private svgSizeHint;
+    /** Mudlet setSvgTint(label, colour) — `color` is any CSS colour. */
+    setSvgTint(name: string, color: string): boolean;
+    /** Mudlet resetSvgTint(label). */
+    resetSvgTint(name: string): boolean;
+    /** Mudlet setSvgRotation(label, degrees); resetSvgRotation passes 0. */
+    setSvgRotation(name: string, degrees: number): boolean;
+    /** Mudlet setSvgShear(label, shearX, shearY); resetSvgShear passes 0, 0. */
+    setSvgShear(name: string, shearX: number, shearY: number): boolean;
+    /** Mudlet resetSvgTransform(label) — rotation and shear together; the tint stays. */
+    resetSvgTransform(name: string): boolean;
+    private patchSvg;
     show(name: string): boolean;
     hide(name: string): boolean;
     setHtml(name: string, html: string): boolean;
+    /** TLabel::reapplyLinkStyle: the links already shown are styled again from
+     *  the text the last pass was given, after the link style or the visited
+     *  links changed. A picture or movie took the text out, so there is none. */
+    private reapplyLinkStyle;
     /** Mudlet setMovie — install (or replace) the label's GIF player. */
     setMovie(name: string, player: MoviePlayer): boolean;
     getMovie(name: string): MoviePlayer | null;
@@ -193,12 +307,41 @@ export declare class LabelManager {
         b: number;
         a: number;
     } | null;
-    setBackgroundImage(name: string, url: string): boolean;
+    /** `size` is the image's intrinsic size when it is already known (an SVG
+     *  read synchronously out of the VFS); `svg` marks an SVG document, which
+     *  is drawn as a layer of its own that fits the label rather than as a
+     *  native-size pixmap. */
+    setBackgroundImage(name: string, url: string, svg?: boolean, size?: {
+        width: number;
+        height: number;
+    }): boolean;
     /** Fills in the intrinsic pixel size resolved asynchronously for `url`
      *  (see backgroundImageSize.ts). No-ops if the label's image has since
      *  changed away from `url` (stale resolution racing a newer call). */
     setBackgroundImageSize(name: string, url: string, width: number, height: number): boolean;
+    /** TLabel::setBackgroundImage with an empty path: an empty pixmap, which
+     *  takes away the picture (raster or SVG), a movie and — as setPixmap()
+     *  does — the text. */
+    clearPixmap(name: string): boolean;
     resetBackgroundImage(name: string): boolean;
+    /** Mudlet `setFont(labelName, family)` on a label. An empty family clears
+     *  the override, leaving the label on whatever it inherits. */
+    setFont(name: string, family: string): boolean;
+    /** The label's own font family, or null when there is no such label.
+     *  An existing label with no override reads as "" — the same "nothing set"
+     *  answer a window with no override gives. */
+    getFont(name: string): string | null;
+    /** Mudlet `setFontSize(labelName, size)` on a label: the point size of its
+     *  widget font. */
+    setFontSize(name: string, size: number): boolean;
+    /**
+     * The point size the label's text is drawn in, or null when there is no
+     * such label. A stylesheet `font-size` wins over the widget font, as QSS
+     * does in Qt; one in pixels is read as points at the CSS 96 dpi (QFont's
+     * pointSizeF for a pixel-sized font). With neither, the `.label` default
+     * of 12px.
+     */
+    getFontSize(name: string): number | null;
     setStyleSheet(name: string, css: string): boolean;
     /** Mudlet `setLinkStyle(labelName, linkColor, linkVisitedColor, underline)`. */
     setLinkStyle(name: string, color: string, visitedColor: string, underline: boolean): boolean;
@@ -217,8 +360,12 @@ export declare class LabelManager {
     activateLink(name: string, href: string): void;
     /** Mudlet `resetLinkStyle(labelName)` — drop any setLinkStyle override. */
     resetLinkStyle(name: string): boolean;
+    /** Mudlet `clearVisitedLinks(labelName)` — forget which links were clicked,
+     *  so they take the link colour again. */
+    clearVisitedLinks(name: string): boolean;
     /** Mudlet `getLabelStyleSheet(name)` — the Qt-style CSS last set via
-     *  {@link setStyleSheet}, or `""` when none is set. Returns `undefined`
+     *  {@link setStyleSheet}, with any {@link setBackgroundColor} declaration
+     *  written into it (a new label starts with one), or `""` when none is set. Returns `undefined`
      *  when the label doesn't exist so the caller can distinguish that case. */
     getStyleSheet(name: string): string | undefined;
     setClickCallback(name: string, fn: ((e: LabelMouseEvent) => void) | undefined): boolean;
@@ -229,6 +376,22 @@ export declare class LabelManager {
     setMouseEnterCallback(name: string, fn: ((e: LabelMouseEvent) => void) | undefined): boolean;
     setMouseLeaveCallback(name: string, fn: ((e: LabelMouseEvent) => void) | undefined): boolean;
     setTooltip(name: string, text: string | undefined): boolean;
+    /** TLabelModel::setAccessibleName. An empty name hands naming back to the
+     *  label's text and tooltip. */
+    setAccessibleName(name: string, accessibleName: string): boolean;
+    /** TLabelModel::effectiveAccessibleName: the name set, else the text the
+     *  label shows, else its tooltip (read literally unless it is rich text,
+     *  as Qt shows it). Undefined for a label that is not there. */
+    getAccessibleName(name: string): string | undefined;
+    /** TLabelModel::setAccessibleButton — `undefined` decides by the callbacks. */
+    setAccessibleButton(name: string, button: boolean | undefined): boolean;
+    /** Host::labelAccessibleRole. Undefined for a label that is not there. */
+    getAccessibleRole(name: string): LabelAccessibleRole | undefined;
+    setLiveRegion(name: string, liveRegion: LabelLiveRegion): boolean;
+    getLiveRegion(name: string): LabelLiveRegion | undefined;
+    /** Host::setAccessibleLabels — every label's keyboard access follows it. */
+    setAccessibleLabels(on: boolean): void;
+    get accessibleLabels(): boolean;
     setClickThrough(name: string, value: boolean): boolean;
     setCursor(name: string, cursor: string | undefined): boolean;
     raise(name: string): boolean;

package/dist-lib/ui/labels/LabelOverlay.d.ts

@@ -1,6 +1,25 @@
 import type { LabelManager } from './LabelManager';
 import './LabelOverlay.css';
 export declare function domButtonToMudlet(type: string, domButton: number): string;
+/** Mudlet's `event.buttons`: every button held while the event happened —
+ *  `{"LeftButton"}` on a left press, `{}` on its release. */
+export declare function domButtonsToMudlet(domButtons: number): string[];
+export interface PressHistory {
+    time: number;
+    button: number;
+    double: boolean;
+}
+/**
+ * Whether a press is the second half of a double-click. Qt delivers that press
+ * as a mouseDoubleClickEvent *instead of* a press, so TLabel runs the
+ * double-click callback and not the click one — and the press after it is an
+ * ordinary press again. The DOM reports it as a second pointerdown and then a
+ * separate dblclick, which ran the click callback twice. `detail` is the click
+ * count where the browser fills it in on pointerdown; where it is 0, the
+ * previous press (`prev`, which the caller keeps from the last return)
+ * stands in for it.
+ */
+export declare function classifyPress(detail: number, button: number, time: number, prev: PressHistory | null): PressHistory;
 interface LabelOverlayProps {
     manager: LabelManager;
     parent: string;

package/dist-lib/ui/labels/backgroundImageSize.d.ts

@@ -2,9 +2,28 @@ export declare function resolveSvgIntrinsicSize(url: string): Promise<{
     width: number;
     height: number;
 } | null>;
+export declare function isSvgUrl(url: string): boolean;
 /** Exported for tests. Mirrors Qt's defaultSize(): explicit width+height
  *  wins, else the viewBox extent, else no intrinsic size (null). */
 export declare function parseSvgIntrinsicSize(svgText: string): {
     width: number;
     height: number;
 } | null;
+/**
+ * Whether `bytes` are worth handing to an SVG parser, the way TLabel::svgCandidate
+ * decides it: gzip magic, or the first character past any byte order mark and
+ * whitespace being `<`. Mudlet reads a file by its content rather than its
+ * name, so a raster saved as `.svg` is still a raster, and an SVG under any
+ * name is still an SVG. The parser is the authority on what really is one.
+ */
+export declare function isSvgCandidate(bytes: Uint8Array): boolean;
+/**
+ * The document size of an SVG held in `bytes`, synchronously — or null when it
+ * is not an SVG the browser can parse, or has no size to offer (no width,
+ * height or viewBox). Gzipped documents are not inflated here; they resolve
+ * through {@link resolveSvgIntrinsicSize} like a remote URL does.
+ */
+export declare function svgIntrinsicSizeFromBytes(bytes: Uint8Array): {
+    width: number;
+    height: number;
+} | null;

package/dist-lib/ui/labels/labelModel.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The text-side half of Mudlet's `TLabelModel` (src/TLabelModel.cpp): what a
+ * label does to the text and the stylesheet it is given, kept apart from the
+ * widget so it can be ported line for line. Two jobs:
+ *
+ *  - {@link styleSheetWithoutBackgroundImage}, which `resetBackgroundImage`
+ *    applies to the label's own stylesheet;
+ *  - the link-styling pass (`TLabelModel::styleLinks` and friends): every
+ *    `<a href=…>` in a label's text gets an inline `style` carrying the colours
+ *    `setLinkStyle` asked for, because QTextDocument reads neither the widget
+ *    stylesheet nor the palette for link colours. `getLabelText` answers with
+ *    the styled text, so the pass has to happen here, and each tag it rewrote is
+ *    remembered so the text can be given back as it was written — on
+ *    `resetLinkStyle`, and when a script echoes what it read back.
+ *
+ * Indices are UTF-16 code units, which is what both QString and a JS string
+ * index by, so the scanners carry over unchanged.
+ */
+/** A tag the last styling pass rewrote, and what it was given as. */
+export interface StyledAnchor {
+    styled: string;
+    original: string;
+}
+/** The link-styling state a label carries between passes (TLabelModel's
+ *  `mUnstyledText`, `mStyledText` and `mStyledAnchors`). */
+export interface LinkStyleState {
+    /** The text the last pass was given, before any styling. */
+    unstyled: string;
+    /** What the last pass produced. */
+    styled: string;
+    anchors: StyledAnchor[];
+}
+export interface LinkStyle {
+    color?: string;
+    visitedColor?: string;
+    underline: boolean;
+}
+/**
+ * `sheet` with every background-image declaration taken out, and nothing else
+ * touched. Comments, quoted strings and a url()'s contents hold no declarations
+ * and no braces, as in CSS; a declaration starts the sheet or follows a ';' or
+ * a rule's '}', so selector text such as `QLabel#background-image:hover` is not
+ * one. Geyser.Label carries a Lua copy of the same scanner and the specs
+ * compare the two character for character, so this follows the C++ exactly.
+ */
+export declare function styleSheetWithoutBackgroundImage(sheet: string): string;
+/**
+ * Whether `text` holds an anchor tag: a `<a` followed by whitespace whose
+ * closing `>` comes before any other `<`. Not a case-insensitive
+ * contains("<a "): that cannot tell a tag from prose.
+ */
+export declare function containsAnchorTag(text: string): boolean;
+/** TLabelModel::linkStyledText — what TLabel::setText shows for `text`, with
+ *  whatever the last pass injected into it put back first. */
+export declare function linkStyledText(text: string, style: LinkStyle | undefined, visited: ReadonlySet<string> | undefined, state: LinkStyleState | undefined, current: string): {
+    text: string;
+    state: LinkStyleState;
+};
+/** TLabelModel::restyledText — the last pass's input styled again, after the
+ *  link style or the visited links changed. */
+export declare function restyledText(style: LinkStyle | undefined, visited: ReadonlySet<string> | undefined, state: LinkStyleState): {
+    text: string;
+    state: LinkStyleState;
+};

package/dist-lib/ui/labels/qColor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `QColor(QString)` for the forms Mudlet's colour arguments accept, answering
+ * `[r, g, b]` (0..255) or null for a string QColor would call invalid.
+ *
+ * Deliberately not `CSS.supports('color', …)`: CSS takes far more than QColor
+ * does (`rgb(…)`, `hsl(…)`, `currentcolor`), so a script that worked here would
+ * be refused by Mudlet, and it reads `#AARRGGBB` as `#RRGGBBAA`. The forms are
+ * Qt's own: `#RGB`, `#RRGGBB`, `#AARRGGBB`, `#RRRGGGBBB`, `#RRRRGGGGBBBB`, and
+ * the SVG 1.0 colour keywords, case-insensitively. A half-written hex such as
+ * `#ff` is invalid, as it is in Qt. Alpha is not returned: the callers here
+ * (setSvgTint) build an opaque colour from the three channels.
+ */
+export declare function parseQColor(input: string): [number, number, number] | null;

package/dist-lib/ui/labels/qtCss.d.ts

@@ -1,5 +1,8 @@
 import type React from 'react';
-export declare function cssTextToStyle(css: string): React.CSSProperties;
+/** A stylesheet's flat declarations as inline style, with those of a
+ *  `<widget> { … }` ruleset — a button's sheet is a QPushButton's, which
+ *  setButtonStyleSheet callers write as `QPushButton { … }`. */
+export declare function cssTextToStyle(css: string, widget?: string): React.CSSProperties;
 export interface QtMargin {
     top: number;
     right: number;
@@ -17,7 +20,7 @@ export interface CssParts {
 export declare function cssTextToParts(css: string): CssParts;
 export declare function userWindowQssToScopedCss(qss: string, scope: string): string;
 export declare function cmdLineQssToScopedCss(qss: string, scope: string): string;
-/** Qt objectNames (from Mudlet's `.ui` files) that mudix mirrors onto a DOM node
+/** Qt objectNames (from Mudlet's `.ui` files) that Mudlet Web mirrors onto a DOM node
  *  via `data-qt-object`, so package stylesheets addressing them keep working.
  *  Reference these instead of writing the raw string at the render site. */
 export declare const QT_OBJECT_NAMES: {
@@ -37,9 +40,9 @@ export declare const QT_OBJECT_NAMES: {
 /**
  * Rewrite the Qt selectors in an app/profile-level stylesheet — objectName forms
  * (`QWidget#widget_panel`) and mapped widget types (`QDockWidget::title`) — onto
- * the DOM they correspond to in mudix. Returns the input unchanged when it holds
+ * the DOM they correspond to in mudlet. Returns the input unchanged when it holds
  * no Qt selector at all, which is the common case for CSS written against
- * mudix's own `.mudix-*` classes.
+ * Mudlet Web's own `.mudlet-*` classes.
  *
  * A rule whose selector we rewrote also gets its *declarations* translated
  * (`qtDeclarationsToCss`): that body was written for Qt, so it may carry
@@ -56,3 +59,8 @@ export declare function qtAlignmentToFlex(val: string): Record<string, string>;
 export declare function extractQtAlignment(css: string): string | undefined;
 export declare function extractQtScaledContents(css: string): boolean | undefined;
 export declare function extractQtWordWrap(css: string): boolean | undefined;
+/** The text a `qproperty-text: "…"` declaration gives a label, or undefined
+ *  when the sheet sets none. Qt writes a qproperty through the widget's own
+ *  setter — QLabel::setText — so the label's text is replaced there and then,
+ *  rather than styled at paint time. Last one wins, as in Qt. */
+export declare function extractQtText(css: string): string | undefined;

package/dist-lib/ui/landmarks.d.ts

@@ -0,0 +1,9 @@
+/**
+ * DOM ids for the two places a keyboard user needs to reach directly on the
+ * session screen. They are shared because the skip links in `ProfileSession`
+ * live several components away from the elements they target — the console is
+ * rendered into a detached host by `ContentLayout`, the command line by
+ * `CommandBar` — so a literal in each file would silently drift apart.
+ */
+export declare const MAIN_OUTPUT_ID = "mudlet-output";
+export declare const COMMAND_INPUT_ID = "mudlet-command-input";

package/dist-lib/ui/launcher/ActionMenu.d.ts

@@ -0,0 +1,19 @@
+export interface MenuAction {
+    label: string;
+    onSelect: () => void;
+    disabled?: boolean;
+    danger?: boolean;
+}
+interface Props {
+    /** Accessible name of the trigger, e.g. "More actions for Achaea". */
+    label: string;
+    actions: MenuAction[];
+    className?: string;
+    disabled?: boolean;
+    /** Visible trigger content; defaults to a bare ⋯ icon. */
+    children?: React.ReactNode;
+}
+/** A "⋯" button that opens a small menu of actions below it, right-aligned
+ *  to the button so it never runs off the edge of a tile or the banner. */
+export declare function ActionMenu({ label, actions, className, disabled, children }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/launcher/GameDetails.d.ts

@@ -0,0 +1,21 @@
+import type { BundledGame } from '../../mud/games/bundledGames';
+import type { MudConnection } from '../../storage';
+interface Props {
+    game: BundledGame;
+    connections: MudConnection[];
+    busy: boolean;
+    /** Set up a profile for the game — the prefilled Add form. */
+    onPlay: (game: BundledGame) => void;
+    /** Connect one of the player's existing profiles for this game. */
+    onConnect: (c: MudConnection) => void;
+    onClose: () => void;
+}
+/**
+ * A game's details: a card centred over the launcher (a bottom sheet on
+ * phones), the same whether the game was picked from the grid, the full
+ * catalogue or the search box. Centred rather than a side drawer — on a wide
+ * screen a drawer opens at the window's edge, far from the tile that opened
+ * it. Focus is held inside while it's open and handed back on close.
+ */
+export declare function GameDetails({ game, connections, busy, onPlay, onConnect, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/launcher/GameSection.d.ts

@@ -0,0 +1,18 @@
+import type { BundledGame } from '../../mud/games/bundledGames';
+import type { MudConnection } from '../../storage';
+/** First sentence-or-so of a blurb, for a tile. */
+export declare function gameTeaser(description: string, max?: number): string;
+interface Props {
+    /** The player's profiles — a tile says when one is already for its game. */
+    connections: MudConnection[];
+    onSelect: (game: BundledGame) => void;
+}
+/** Fisher–Yates; returns a new array. */
+export declare function shuffle<T>(items: readonly T[], random?: () => number): T[];
+/**
+ * The bundled catalogue: a couple of rows by default, or every game in
+ * a filterable grid behind "Browse all". Picking a game opens its details;
+ * nothing is created until the player chooses Play there and submits the form.
+ */
+export declare function GameSection({ connections, onSelect }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/launcher/LauncherSearch.d.ts

@@ -0,0 +1,23 @@
+import type { BundledGame } from '../../mud/games/bundledGames';
+import { type MudConnection } from '../../storage';
+import { type TypedAddress } from './launcherModel';
+interface Props {
+    connections: MudConnection[];
+    /** Catalogue to search — empty in a branded build, which has none. */
+    games: readonly BundledGame[];
+    disabled?: boolean;
+    onConnect: (c: MudConnection) => void;
+    onSelectGame: (g: BundledGame) => void;
+    onAddress: (a: TypedAddress) => void;
+}
+/**
+ * "Where to?" — one box that finds a profile, a catalogue game, or takes a
+ * server address as typed. An ARIA combobox: arrows move through the options,
+ * Enter takes one, Escape clears. "/" focuses it from anywhere on the screen.
+ */
+export declare function LauncherSearch({ connections, games, disabled, onConnect, onSelectGame, onAddress }: Props): import("react/jsx-runtime").JSX.Element;
+/** Up to two letters standing for a name: the initials of its first two
+ *  words ("My test MUD" → "MT"), or its first two letters when it is one word
+ *  ("alteraeon.com" → "AL"). */
+export declare function nameInitials(name: string): string;
+export {};

package/dist-lib/ui/launcher/ProfileArt.d.ts

@@ -0,0 +1,20 @@
+import type { MudConnection } from '../../storage';
+/** The logo a profile is drawn with: its own icon (setProfileIcon) first, else
+ *  its game's vendored logo. A profile made from the catalogue keeps the game's
+ *  logo without storing a copy — matched by host too, so a renamed or second
+ *  "Achaea (2)" is recognised. Null when there is neither. */
+export declare function profileIconUrl(connection: MudConnection): string | null;
+interface Props {
+    /** The logo to glow behind, or null for the name-derived aurora. */
+    icon: string | null;
+    /** Seeds the aurora when there is no icon. */
+    name: string;
+}
+/**
+ * The backdrop behind a profile or game: its logo blown up and blurred into a
+ * glow when it has one, otherwise an aurora coloured from its name. Purely
+ * decorative — callers draw the logo or name on top, and a scrim keeps that
+ * readable whatever colours land here.
+ */
+export declare function ProfileArt({ icon, name }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist-lib/ui/launcher/ProfileSection.d.ts

@@ -0,0 +1,43 @@
+import { type MudConnection } from '../../storage';
+/** What a profile tile or the banner can do, shared so both stay in step. */
+export interface ProfileHandlers {
+    connecting: boolean;
+    connectingId: string | null;
+    /** Profiles another tab holds open — one tab per profile (profileLock.ts),
+     *  so these can't be connected or opened from here. */
+    openIds: Set<string>;
+    onConnect: (c: MudConnection) => void;
+    onOpen: (c: MudConnection) => void;
+    onEdit: (c: MudConnection) => void;
+    onDuplicate: (c: MudConnection) => void;
+    onDelete: (c: MudConnection) => void;
+}
+/**
+ * "Continue playing": the profile played most recently, large, with Connect
+ * one click away. The logo sits in a fixed slot and Connect in its own column,
+ * so a wide logo, a tiny one, or none at all never moves the button.
+ */
+export declare function LauncherHero({ connection: c, handlers: h }: {
+    connection: MudConnection;
+    handlers: ProfileHandlers;
+}): import("react/jsx-runtime").JSX.Element;
+interface ShelfProps {
+    /** Profiles to show, in the player's own order (the banner's one excluded). */
+    connections: MudConnection[];
+    handlers: ProfileHandlers;
+    editingId: string | null;
+    onAddClick: () => void;
+    /** The new order of the grid's profiles, after a drag or a Move entry. */
+    onReorder: (orderedIds: string[]) => void;
+    /** The Import menu, rendered in the section header. */
+    importMenu: React.ReactNode;
+}
+/**
+ * The player's profiles, in the order they arrange them. Dragging a tile lifts
+ * it into a copy that follows the pointer, opens a dashed gap where it would
+ * land, and slides the other tiles over with a FLIP animation. A press that
+ * doesn't travel is a plain click and connects, as before; a drag never does.
+ * The ⋯ menu's Move entries do the same from the keyboard.
+ */
+export declare function ProfileShelf({ connections, handlers, editingId, onAddClick, onReorder, importMenu }: ShelfProps): import("react/jsx-runtime").JSX.Element;
+export {};