@mudlet/mudlet-web 0.5.0 → 1.0.1

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

@@ -2,7 +2,7 @@ interface Props {
     onClose: () => void;
 }
 /** Small "About" dialog reachable from the connection screen — wordmark,
- *  tagline and description come from the active brand (stock mudix by
+ *  tagline and description come from the active brand (stock Mudlet Web by
  *  default) plus a link to the source repository when the brand sets one. */
 export declare function AboutModal({ onClose }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -18,7 +18,7 @@ export interface BrandLoginFieldsProps extends Pick<LandingProps, 'openProfile'
 /**
  * Unstyled login form for custom branded landings: account (+ optional
  * password) input, Connect submit, optional Open-offline button. No CSS is
- * applied — every element carries a stable `mudix-login-*` class for the
+ * applied — every element carries a stable `mudlet-login-*` class for the
  * brand's own stylesheet to target. Wraps `useBrandLogin`; for full control
  * over markup, call that hook directly instead of using this component.
  */

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

@@ -0,0 +1,23 @@
+import type { SignInOffer } from '../mud/CharLoginController';
+interface Props {
+    connectionName: string;
+    offer: SignInOffer;
+    /** Close the dialog. For a server-driven offer the console link stays; for
+     *  our own flow the sign-in keeps waiting until it completes or times out. */
+    onClose: () => void;
+    /** Client-driven flow only: drop it and let the game run its own sign-in. */
+    onUseGameSignIn?: () => void;
+}
+/**
+ * A GMCP `Char.Login` browser sign-in waiting for the player to open it.
+ *
+ * Mudlet launches the system browser itself, and so do we while the player's
+ * last gesture is fresh (`openSignInPage`). This dialog is the fallback for
+ * when it is not: a web page may only open a tab from a user gesture, so the
+ * address becomes this button — a plain link with
+ * `noopener`, which no popup blocker stops and which gives the provider's page
+ * no handle back on ours. The same link is in the console, for a player who
+ * closes this.
+ */
+export declare function BrowserSignInModal({ connectionName, offer, onClose, onUseGameSignIn }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -11,17 +11,26 @@ export interface CmdLineMenuEntry {
  * getCommandLineMenuEvents. Right-clicking the command bar shows entries from
  * this registry; clicking one raises the registered event with the current
  * command-line text as the first argument.
+ *
+ * Every command line has a menu of its own, as on desktop (each TCommandLine
+ * holds its own map): an entry added to a createCommandLine() line is not on the
+ * main bar's menu, and removing it by the main bar's name finds nothing. The
+ * main command bar is `'main'`, the default throughout.
  */
 export declare class CmdLineMenuRegistry {
-    private entries;
+    /** Command line name → that line's entries, by unique name. */
+    private menus;
     private subscribers;
     private dispatcher;
     subscribe(cb: () => void): () => void;
     private notify;
     setDispatcher(fn: ((eventName: string, args: unknown[]) => void) | null): void;
-    add(uniqueName: string, eventName: string, displayName?: string): boolean;
-    remove(uniqueName: string): boolean;
-    list(): CmdLineMenuEntry[];
+    private menu;
+    add(uniqueName: string, eventName: string, displayName?: string, cmdLine?: string): boolean;
+    remove(uniqueName: string, cmdLine?: string): boolean;
+    list(cmdLine?: string): CmdLineMenuEntry[];
+    /** Forget a command line's menu, along with the command line. */
+    drop(cmdLine: string): void;
     /** Raise the entry's event, passing the current command-line text. */
-    dispatch(uniqueName: string, cmdLineText: string): void;
+    dispatch(uniqueName: string, cmdLineText: string, cmdLine?: string): void;
 }

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

@@ -1,4 +1,3 @@
-import { type BufferWordIndex } from './bufferWords';
 import type { CmdLineMenuRegistry } from './CmdLineMenuRegistry';
 interface CommandBarProps {
     command: string;
@@ -7,17 +6,18 @@ interface CommandBarProps {
     commandInputRef: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
     onSubmit: () => void;
     cmdLineMenu: CmdLineMenuRegistry;
-    /** Tab-completion suggestions added via Mudlet's addCmdLineSuggestion API.
-     *  Merged ahead of command history (dedup, case-insensitive). */
+    /** The main command line's addCmdLineSuggestion words: Tab completes to
+     *  them as well as to the buffer's, and the history ghost offers them. */
     suggestions?: string[];
-    /** Words Mudlet's addCmdLineBlacklist API has taken out of Tab completion.
-     *  Subtractive across every source below, not just `suggestions`. */
+    /** Words Mudlet's addCmdLineBlacklist API has taken out of Tab completion,
+     *  whether they came from the buffer or from `suggestions`. */
     blacklist?: string[];
     /** Mudlet's per-command-line setSaveCommandHistory. False keeps the history
      *  for this session but stops persisting it. */
     saveHistory?: boolean;
-    /** Recency-ordered words seen in output, for argument-word Tab completion. */
-    bufferWords?: BufferWordIndex | null;
+    /** The main console's last lines, oldest first, read at each Tab — what
+     *  TCommandLine::handleTabCompletion completes from besides `suggestions`. */
+    completionLines?: () => readonly string[];
 }
-export declare function CommandBar({ command, onCommandChange, passwordMode, commandInputRef, onSubmit, cmdLineMenu, suggestions, blacklist, saveHistory, bufferWords }: CommandBarProps): import("react/jsx-runtime").JSX.Element;
+export declare function CommandBar({ command, onCommandChange, passwordMode, commandInputRef, onSubmit, cmdLineMenu, suggestions, blacklist, saveHistory, completionLines }: CommandBarProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,10 +1,29 @@
 import { type MudConnection } from '../storage';
 import type { VaultSaver } from './useVaultSaver';
+/** Split a host string that may carry a trailing port (`host:port` or
+ *  `host port`) into its parts, so pasting a full address moves the port into
+ *  the Port field. Returns `port: undefined` when no trailing numeric port is
+ *  present, leaving the Port field untouched.
+ *
+ *  An IPv6 literal is all colons and hex, so the old non-greedy `(.*?)[\s:]+(\d+)$`
+ *  matched its own tail: typing `2001:db8::1` left host `2001:db8` and port 1,
+ *  and saved it that way (issue #56). Only the bracketed form `[::1]:4000` has
+ *  an unambiguous port, so that is the only IPv6 shape that gets split. */
+export declare function splitHostPort(value: string): {
+    host: string;
+    port?: string;
+};
 interface Props {
     /** The connection to edit, or null to add a new one. */
     connection: MudConnection | null;
+    /** Field values to start a new connection from, when `connection` is null —
+     *  a bundled game's host/port/blurb, so picking a game fills the form in
+     *  rather than dialing straight away. Ignored when editing. */
+    preset?: Omit<MudConnection, 'id'> | null;
     /** Whether this is the very first connection (drives the title copy). */
     firstConnection: boolean;
+    /** Overrides the generated dialog title (e.g. "Add Achaea"). */
+    title?: string;
     busy: boolean;
     onAdd: (data: Omit<MudConnection, 'id'>) => string;
     onUpdate: (id: string, data: Omit<MudConnection, 'id'>) => void;
@@ -14,5 +33,5 @@ interface Props {
      *  on submit — a prompt rendered from here would unmount with it. */
     vaultSaver: VaultSaver;
 }
-export declare function ConnectionFormModal({ connection, firstConnection, busy, onAdd, onUpdate, onClose, vaultSaver }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function ConnectionFormModal({ connection, preset, firstConnection, title: titleOverride, busy, onAdd, onUpdate, onClose, vaultSaver }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,3 +1,5 @@
+import './launcher/launcher.css';
+import type { BundledGame } from '../mud/games/bundledGames';
 import { type MudConnection } from '../storage';
 interface Props {
     connections: MudConnection[];
@@ -9,6 +11,12 @@ interface Props {
     onUpdate: (id: string, data: Omit<MudConnection, 'id'>) => void;
     onDelete: (id: string) => void;
     onOpenSettings: () => void;
+    /** A bundled game named by a `?play=<game>` deep link, offered once on
+     *  mount. Null when the page wasn't opened from such a link. */
+    linkedGame?: BundledGame | null;
+    /** Called once `linkedGame` has been offered, so the caller can drop it
+     *  from its state and clean the parameter out of the URL. */
+    onLinkedGameHandled?: () => void;
 }
-export declare function ConnectionScreen({ connections, connecting, connectingId, onConnect, onOpen, onAdd, onUpdate, onDelete, onOpenSettings }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function ConnectionScreen({ connections, connecting, connectingId, onConnect, onOpen, onAdd, onUpdate, onDelete, onOpenSettings, linkedGame, onLinkedGameHandled }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,28 @@
+import type { BundledGame } from '../mud/games/bundledGames';
+import type { MudConnection } from '../storage';
+interface Props {
+    game: BundledGame;
+    /** Existing profiles for this game — never empty; with none the caller goes
+     *  straight to the prefilled Add form and this never renders. */
+    profiles: MudConnection[];
+    busy: boolean;
+    /** Play an existing profile — opens it and dials. */
+    onPlay: (connection: MudConnection) => void;
+    /** Open an existing profile without dialing, as the launcher tiles do. */
+    onOpen: (connection: MudConnection) => void;
+    /** Set up another profile for the game (opens the prefilled Add form). */
+    onCreate: () => void;
+    onClose: () => void;
+}
+/**
+ * Where a `?play=<game>` link lands when the player already has profiles for
+ * that game. The link can't know whether they've played it before, so it asks
+ * rather than guessing: dialing an existing profile would bypass the one they
+ * just made, and making a new one every visit would litter the launcher with
+ * duplicates.
+ *
+ * A click on the game's own tile doesn't come through here — the profiles are
+ * already on screen right above it, so that click goes straight to the form.
+ */
+export declare function GameLinkPrompt({ game, profiles, busy, onPlay, onOpen, onCreate, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -5,7 +5,11 @@ interface HelpModalProps {
     connectionId?: string;
     /** Topic to open on — defaults to the migration guide. */
     initialTopic?: string;
+    /** Extra class on the dialog. Used by a caller that opens the manual over
+     *  its own dialog rather than instead of it, to lift this one above the
+     *  `.modal` stacking level it would otherwise sit under. */
+    className?: string;
     onClose: () => void;
 }
-export declare function HelpModal({ connectionId, initialTopic, onClose }: HelpModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function HelpModal({ connectionId, initialTopic, className, onClose }: HelpModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,32 @@
+interface Props {
+    /** Each distinct symbol with the rooms carrying it, commonest first —
+     *  `MapStore.roomSymbolUsage()`. */
+    usage: {
+        symbol: string;
+        rooms: number[];
+    }[];
+    /** A ready-to-use CSS `font-family` value — the same stack the renderer is
+     *  given (`applyMapperSettings`), so the sample column shows the symbol as
+     *  the map draws it rather than as the UI font draws it. The caller
+     *  composes it; a raw family name from the profile has to go through
+     *  `cssFontFamilyLiteral` first. */
+    symbolFont: string;
+    onClose: () => void;
+}
+/**
+ * Mudlet's "Show symbol usage…" dialog (`dlgProfilePreferences::showMapGlyph\
+ * Usage` → `generateMapGlyphDisplay`, and the `glyph_usage.ui` table it fills).
+ *
+ * Desktop's table has six columns; this has four. The two that are missing are
+ * its pair of sample cells — the symbol drawn with only the chosen font, and
+ * drawn with any font the system has — together with the status icon that says
+ * which of the two worked. All three answer one question, "can this font draw
+ * this symbol", and it needs per-glyph coverage testing: `QFontMetrics::in\
+ * FontUcs4`, which has no browser counterpart. `mudlet-map-renderer` draws the
+ * string and lets the browser fall back, so the client cannot tell a symbol it
+ * drew from one the fallback drew — and neither can this dialog. The columns it
+ * does have are the ones the report is really for: which symbols a map uses,
+ * how heavily, and where.
+ */
+export declare function MapSymbolUsageModal({ usage, symbolFont, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -10,8 +10,9 @@ export interface MouseEventEntry {
 }
 /**
  * Backs Mudlet's addMouseEvent / removeMouseEvent / getMouseEvents
- * (Host::mConsoleActions). Right-clicking the main output area shows entries
- * from this registry; clicking one raises the registered event. addMouseEvent
+ * (Host::mConsoleActions). Right-clicking any console — the main output area,
+ * a miniconsole or a user window — shows entries from this registry; clicking
+ * one raises the registered event. addMouseEvent
  * refuses a duplicate uniqueName (matching Mudlet's warn-and-return-nil).
  */
 export declare class MouseEventRegistry {
@@ -26,6 +27,32 @@ export declare class MouseEventRegistry {
     add(uniqueName: string, eventName: string, displayName?: string, tooltip?: string): boolean;
     remove(uniqueName: string): boolean;
     list(): MouseEventEntry[];
-    /** Raise the entry's event. Mudlet passes the originating window name. */
-    dispatch(uniqueName: string): void;
+    /**
+     * Raise the entry's event the way TTextEdit::slot_mouseAction does: with
+     * the entry's unique name, the console it was chosen from, and that
+     * console's selection — first character's column and line, then the last
+     * one's (all 0 when nothing is selected).
+     */
+    dispatch(uniqueName: string, window?: string, selection?: {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }): void;
 }
+/**
+ * The registry's entries as right-click menu items for the console `window`.
+ * Desktop adds them to every console's menu — main, miniconsoles and user
+ * windows alike (TTextEdit::contextMenuEvent) — and each one, when chosen,
+ * reports the console and its selection (see {@link MouseEventRegistry.dispatch}).
+ */
+export declare function mouseEventMenuItems(registry: MouseEventRegistry, window: string, selection: {
+    startX: number;
+    startY: number;
+    endX: number;
+    endY: number;
+}): {
+    label: string;
+    tooltip?: string;
+    onClick: () => void;
+}[];

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

@@ -0,0 +1,22 @@
+import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+interface NotepadModalProps {
+    connectionId: string;
+    connectionName: string;
+    vfs: ProfileVFS | null;
+    /** Sends one command as if typed — aliases and the local echo included,
+     *  as desktop's `Host::send` does for the notepad's send buttons. */
+    onSend: (command: string) => void;
+    onClose: () => void;
+}
+/**
+ * Mudlet's Notepad (`dlgNotepad`): named tabs of free text kept per profile in
+ * `notes.json`, with a find bar and controls that send the notes to the game
+ * line by line.
+ *
+ * Written a beat after typing stops, on every tab change, on close and when the
+ * page is hidden, so a closed browser tab does not take the last sentence with
+ * it. Escape does not close the window — dlgNotepad is a QMainWindow, and
+ * Escape there closes the find bar.
+ */
+export declare function NotepadModal({ connectionId, connectionName, vfs, onSend, onClose }: NotepadModalProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -11,7 +11,22 @@ interface ResizableModalProps {
     headerExtra?: React.ReactNode;
     className?: string;
     bodyClassName?: string;
+    /**
+     * Escape closes the dialog. Default true — desktop Mudlet builds this class
+     * of window as a `QDialog` (`dlgPackageManager`, `dlgModuleManager`,
+     * `dlgPackageExporter`, `dlgProfilePreferences`), and a QDialog rejects on
+     * Escape for free.
+     *
+     * Pass false for the editor-hosting modals, whose desktop counterparts are
+     * `QMainWindow`s precisely so Escape stays available to what is inside them:
+     * `dlgTriggerEditor` (Mudlet `src/dlgTriggerEditor.h:104`) spends Escape on
+     * leaving key-grab mode (`src/dlgTriggerEditor.cpp:12527`), and `dlgNotepad`
+     * (`src/dlgNotepad.h:42`) on closing its find bar (`dlgNotepad.cpp:651`) —
+     * the same jobs Escape has in ScriptEditorPanel's key capture, LuaEditor and
+     * ScriptSearch. May vary over the dialog's life; see `ModalFocusOptions`.
+     */
+    closeOnEscape?: boolean;
     children: React.ReactNode;
 }
-export declare function ResizableModal({ title, onClose, savedBounds, onBoundsChange, minW, minH, defaultW, defaultH, headerExtra, className, bodyClassName, children, }: ResizableModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function ResizableModal({ title, onClose, savedBounds, onBoundsChange, minW, minH, defaultW, defaultH, headerExtra, className, bodyClassName, closeOnEscape, children, }: ResizableModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,4 +1,5 @@
 import type { ProfileVFS } from '../scripting/vfs/ProfileVFS';
+import type { WindowManager } from './windows/WindowManager';
 import type { TlsStatus } from '../mud/events';
 interface SettingsModalProps {
     onClose: () => void;
@@ -8,6 +9,14 @@ interface SettingsModalProps {
     /** TLS state of the live session, when there is one. Drives the certificate
      *  box below the secure-connection reminder. */
     tlsStatus?: TlsStatus | null;
+    /** The live session's window manager, for the map-file actions Mudlet keeps
+     *  on its Mapper preference page. Absent on the connection screen, where
+     *  there is no map to act on and the card is not rendered. */
+    windows?: WindowManager | null;
+    /** Opens the Logs browser. Mudlet's Log options page owns the log format
+     *  and folder; ours owns the switch, and the rest of what a player wants to
+     *  do with logs lives in that browser — so Settings offers the door. */
+    onOpenLogs?: () => void;
 }
-export declare function SettingsModal({ onClose, connectionId, vfs, tlsStatus }: SettingsModalProps): import("react/jsx-runtime").JSX.Element;
+export declare function SettingsModal({ onClose, connectionId, vfs, tlsStatus, windows, onOpenLogs }: SettingsModalProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -12,7 +12,9 @@ interface Props {
  * Mudlet reacts to a certificate failure by opening Preferences on the
  * connection tab with the offending checkbox highlighted; the browser
  * equivalent is to say which setting would allow it and let the user undo the
- * port change in one click.
+ * port change in one click. What it must not do — and used to — is describe
+ * every failure as a certificate refusal and then advise a checkbox this proxy
+ * never renders; see `describeTlsFailure`.
  */
 export declare function TlsAlertBanner({ status, revertPort, onRevert, onDismiss }: Props): import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -1,5 +1,6 @@
 import { type BrandToolbarContext } from '../branding';
 import type { SessionStatus } from '../mud/events';
+import type { AddonCommand } from './commands/addonCommands';
 interface ToolbarProps {
     connectionName: string;
     status: SessionStatus;
@@ -8,12 +9,25 @@ interface ToolbarProps {
     onReconnect: () => void;
     onNewConnection: () => void;
     onOpenMap: () => void;
+    /** A script set setConfig("mapperButton", "disabled"): the map entries grey out. */
+    mapDisabled?: boolean;
     onOpenScripts: () => void;
     onOpenFiles: () => void;
+    /** Mudlet's Notepad: the profile's notes.txt. */
+    onOpenNotepad: () => void;
     onOpenLogs: () => void;
     onOpenDocs: () => void;
     onOpenHelp: () => void;
     onOpenSettings: () => void;
+    /** The About dialog, reachable only from the menu bar — it lives at the
+     *  session's top level rather than here, because a modal rendered inside
+     *  the toolbar is inside the toolbar's stacking context (and, in
+     *  fullscreen, inside its transform, which makes `position: fixed` resolve
+     *  against the bar instead of the window). */
+    onOpenAbout: () => void;
+    /** Mudlet's Alt+L: put the keyboard back on the command line. Only ever
+     *  reached from a shortcut — there is no button for it. */
+    onFocusInputLine: () => void;
     /** Mudlet-format replay recording toggle state + handler. */
     replayRecording: boolean;
     onToggleReplayRecording: () => void;
@@ -25,6 +39,13 @@ interface ToolbarProps {
     onContextMenu?: (e: React.MouseEvent<HTMLDivElement>) => void;
     /** Capabilities handed to brand toolbar buttons (send / raiseEvent). */
     brandContext?: BrandToolbarContext;
+    /** Commands a package placed with addCommand, for the surfaces that put
+     *  them on a bar. Drawn after the stock buttons, in placement order. */
+    addonCommands?: AddonCommand[];
+    /** The same commands for the surfaces that put them on the menu bar. A
+     *  command asking for both is in both lists. */
+    addonMenuCommands?: AddonCommand[];
+    onAddonCommandClick?: (id: number) => void;
 }
-export declare function Toolbar({ connectionName, status, ping, onDisconnect, onReconnect, onNewConnection, onOpenMap, onOpenScripts, onOpenFiles, onOpenLogs, onOpenDocs, onOpenHelp, onOpenSettings, replayRecording, onToggleReplayRecording, replaySpeed, onReplaySpeedChange, onReplayStop, onContextMenu, brandContext }: ToolbarProps): import("react/jsx-runtime").JSX.Element;
+export declare function Toolbar({ connectionName, status, ping, onDisconnect, onReconnect, onNewConnection, onOpenMap, mapDisabled, onOpenScripts, onOpenFiles, onOpenNotepad, onOpenLogs, onOpenDocs, onOpenHelp, onOpenSettings, onOpenAbout, onFocusInputLine, replayRecording, onToggleReplayRecording, replaySpeed, onReplaySpeedChange, onReplayStop, onContextMenu, brandContext, addonCommands, addonMenuCommands, onAddonCommandClick }: ToolbarProps): import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,15 +1,20 @@
 import type { MudConnection } from '../storage';
 interface VaultManageButtonProps {
+    /** Every profile, so the manage list can name the ones with a saved login
+     *  (the vault itself stores only ids — it has no idea what they are called). */
     connections: MudConnection[];
-    disabled?: boolean;
+    /** `icon` is the connection screen's header glyph; `row` is the labelled
+     *  button the settings dialog's "Saved logins" card puts on a settings row,
+     *  where a bare glyph in a column of switches would read as decoration. */
+    variant?: 'icon' | 'row';
 }
 /**
- * "Saved logins" on the connection screen's tools row — the one place to lock
- * the vault, change how it opens, drop a stored password or delete the whole
- * thing.
+ * "Saved logins" in the connection screen's header icon row — the one place to
+ * lock the vault, change how it opens, drop a stored password, or delete the
+ * whole thing.
  *
  * Renders nothing when no vault is installed, which is how a branded build gets
  * neither the button nor anything behind it (see `vault/vaultAccess`).
  */
-export declare function VaultManageButton({ connections, disabled }: VaultManageButtonProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function VaultManageButton({ connections, variant }: VaultManageButtonProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

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

@@ -1,2 +1,5 @@
 import { type VaultUIProps } from '../vault/vaultAccess';
+/** "The one password in here", "The 3 passwords and 1 saved sign-in in here" —
+ *  the subject of the delete-vault warning, naming what is about to be lost. */
+export declare function describeVaultContents(passwords: number, signIns: number): string;
 export declare function VaultModal({ mode, reason, seed, connectionNames, onDone }: VaultUIProps): import("react/jsx-runtime").JSX.Element;

package/dist-lib/ui/buttons/ButtonsBar.d.ts

@@ -6,12 +6,14 @@ interface ButtonsLayerProps {
     connectionId: string;
     engineRef: RefObject<ScriptingEngine | null>;
     vfs: ProfileVFS | null;
+    /** The main command line, which gets focus back after every click. */
+    commandInputRef?: RefObject<HTMLElement | null>;
 }
 /**
  * Returns the four edge strips of toolbars (top/bottom/left/right). The caller
  * places each strip in the appropriate spot inside ContentLayout.
  */
-export declare function useButtonStrips({ connectionId, engineRef, vfs }: ButtonsLayerProps): {
+export declare function useButtonStrips({ connectionId, engineRef, vfs, commandInputRef }: ButtonsLayerProps): {
     top: import("react/jsx-runtime").JSX.Element;
     bottom: import("react/jsx-runtime").JSX.Element;
     left: import("react/jsx-runtime").JSX.Element;

package/dist-lib/ui/buttons/inactiveButtons.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The buttons, per profile, that cannot be active whatever their switch says:
+ * their Lua will not compile. Desktop's TAction::compileScript leaves such a
+ * button with `mOK_code` false, so `Tree::activate` refuses it and the toolbar
+ * builders (TToolBar/TEasyButtonBar::addActionButtons, ActionUnit's
+ * constructToolbar) leave it off — a toolbar or menu that will not compile
+ * takes its buttons with it.
+ *
+ * The ScriptingEngine owns the compile check and publishes its answer here;
+ * the button bar reads it. Kept outside the store, since it is derived from the
+ * buttons rather than part of them, and outside the engine, whose instance the
+ * bar only holds by ref.
+ */
+declare class InactiveButtonRegistry {
+    private readonly byConnection;
+    private readonly listeners;
+    subscribe: (fn: () => void) => (() => void);
+    /** The ids for this profile. The same Set until they change, so it can be
+     *  a useSyncExternalStore snapshot. */
+    get: (connectionId: string) => ReadonlySet<string>;
+    set(connectionId: string, ids: ReadonlySet<string>): void;
+    clear(connectionId: string): void;
+}
+export declare const inactiveButtons: InactiveButtonRegistry;
+export {};

package/dist-lib/ui/cmdline/CommandLineManager.d.ts

@@ -1,4 +1,5 @@
 import { OverlayLayerOrder } from '../layout/overlayLayerOrder';
+import { SubCommandLine, type CmdLineHost } from './subCommandLine';
 export interface CmdLineCreateOptions {
     /** Parent window id ('main' for the main viewport). */
     parent?: string;
@@ -50,6 +51,12 @@ export declare class CommandLineManager {
     /** Per-cmdline imperative control registered by the React mount —
      *  selectAll() drives <input>.select() (Mudlet selectCmdLineText). */
     private readonly controls;
+    /** Per-cmdline keyboard state (history, Tab) — held here rather than in
+     *  the React input so it outlives a remount. */
+    private readonly models;
+    /** The profile settings and Tab pool every command line reads. Set by the
+     *  ScriptingEngine. */
+    cmdLineHost: CmdLineHost;
     constructor(overlayZ?: OverlayLayerOrder);
     /** Mudlet createCommandLine(name, x, y, w, h) — false when a cmd line with
      *  that name already exists. */
@@ -82,6 +89,18 @@ export declare class CommandLineManager {
     getValue(name: string): string;
     setAction(name: string, cb: ((text: string) => void) | null): boolean;
     getAction(name: string): ((text: string) => void) | null;
+    /** Where Enter goes on a command line with no action bound: the game, as
+     *  typed input. Set by the ScriptingEngine (its `hostSend`). */
+    onDefaultSend?: (text: string) => void;
+    /**
+     * The user pressed Enter on `name` with `text` in it. Runs the bound
+     * action, or else sends the text the way Mudlet's
+     * TCommandLine::enterCommand falls back to `Host::send`. Returns whether
+     * anything took the text, i.e. whether the line should clear.
+     */
+    submit(name: string, text: string): boolean;
+    /** The keyboard state of command line `name`, made on first use. */
+    model(name: string): SubCommandLine;
     hasAction(name: string): boolean;
     /** Mudlet selectCmdLineText — highlight all text in the input. */
     selectAll(name: string): boolean;

package/dist-lib/ui/cmdline/plainText.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What a command line's text becomes once it leaves the box — desktop's
+ * TCommandLine reads it with QPlainTextEdit::toPlainText(), and
+ * QTextDocument::toPlainText turns a non-breaking space (U+00A0) into an
+ * ordinary space and the Unicode line and paragraph separators (U+2028,
+ * U+2029) into line feeds. So text pasted from a web page or a chat app sends
+ * `pg x`, not `pg<NBSP>x`, and a U+2028 splits the command in two, as a typed
+ * newline does. getCmdLine() reads the same plain text (#375).
+ *
+ * Every replacement is one UTF-16 unit for one, so caret offsets taken on the
+ * raw text still hold on the result.
+ */
+export declare function cmdLinePlainText(text: string): string;
+/** The commands one Enter sends: the plain text, one per line, as
+ *  TCommandLine::enterCommand splits it before Host::send. */
+export declare function cmdLineCommands(text: string): string[];

package/dist-lib/ui/cmdline/subCommandLine.d.ts

@@ -0,0 +1,78 @@
+/**
+ * What a named command line needs from the profile around it. Desktop's
+ * TCommandLine reads all of this off its Host; here the ScriptingEngine
+ * supplies it (see ScriptingEngine's constructor), and a line rendered before
+ * there is an engine falls back to {@link DEFAULT_CMD_LINE_HOST}.
+ */
+export interface CmdLineHost {
+    /** Mudlet's "Auto clear the input line after you sent text". */
+    autoClear(): boolean;
+    /** Mudlet's "Highlight history". */
+    highlightHistory(): boolean;
+    /** Host::isRemoteEchoingActive — the server took ECHO (a password prompt). */
+    remoteEcho(): boolean;
+    /** Mudlet's "Disable password masking". */
+    disablePasswordMasking(): boolean;
+    /** The Tab pool for the command line called `name` (see
+     *  ScriptingAPI.cmdLineCompletionWords). */
+    completionWords(name: string): readonly string[];
+}
+export declare const DEFAULT_CMD_LINE_HOST: CmdLineHost;
+/** The text of a command line and where its selection is ([start, end), a
+ *  caret when they are equal). */
+export interface CmdLineView {
+    text: string;
+    start: number;
+    end: number;
+}
+/**
+ * The keyboard behaviour of one named command line — a createCommandLine line
+ * or a miniconsole's / user window's own — ported from desktop's TCommandLine,
+ * which runs the same code for those as for the main one: input history on
+ * Up/Down (with "Highlight history" prefix search), Tab completion, Escape,
+ * and what Enter leaves behind. Web used to render these as bare inputs that
+ * had none of it (#342).
+ *
+ * Kept outside React and held by the manager that owns the line, so the
+ * history outlives the input being remounted (a dock, an undock, a hide). Each
+ * method takes the line as it is and returns what it should become, or null
+ * when the key changes nothing.
+ */
+export declare class SubCommandLine {
+    readonly name: string;
+    /** mHistoryList: newest first, slot 0 the line being typed. */
+    private historyList;
+    /** mHistoryBuffer: which slot Up/Down stepped to; 0 is the typed line. */
+    private historyBuffer;
+    /** mAutoCompletionCount: the history slot the prefix search is on. */
+    private autoCompletionCount;
+    private readonly tab;
+    constructor(name: string);
+    /** The history, newest first (for tests and debugging). */
+    get history(): readonly string[];
+    /**
+     * Enter: the commands to dispatch (one per line, as TCommandLine splits
+     * the box at line feeds) and what the box holds afterwards — emptied when
+     * "auto clear" is on, else the same text, all selected so the next
+     * keystroke replaces it. The text joins the history unless it is empty or
+     * the server is masking input for a password.
+     */
+    enter(text: string, host: CmdLineHost): {
+        commands: string[];
+        after: CmdLineView;
+    };
+    /** TCommandLine::historyMove — a plain Up (`up` true) or Down. */
+    historyMove(up: boolean, view: CmdLineView, host: CmdLineHost): CmdLineView | null;
+    /** TCommandLine::handleAutoCompletion — the history prefix search. */
+    private autoComplete;
+    /** Tab (`dir` 1) or Shift+Tab (-1); null when there is nothing to complete. */
+    tabComplete(dir: 1 | -1, view: CmdLineView, host: CmdLineHost): {
+        view: CmdLineView;
+        proposal: string;
+    } | null;
+    /** Escape: leave Tab and history browsing, and select everything. */
+    escape(view: CmdLineView): CmdLineView;
+    /** The player edited the text (TCommandLine::processNormalKey and the
+     *  Backspace / Delete / Space cases): back on the typed line. */
+    edited(): void;
+}