@mudlet/mudlet-web 0.4.2 → 0.4.3

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

@@ -62,6 +62,14 @@ export interface LabelState {
      *  `alignment`, it's a widget property that persists across a later
      *  stylesheet that omits it. */
     scaledContents?: boolean;
+    /** Sticky Qt `wordWrap` widget property, captured from a
+     *  `qproperty-wordWrap` declaration in any setStyleSheet call. QLabel
+     *  defaults it to false (and TLabel never sets it), which is why label text
+     *  in Mudlet runs past the widget edge and gets clipped instead of wrapping
+     *  — LabelOverlay renders that as `white-space: nowrap`, and this property
+     *  as `normal`. Sticky across a later stylesheet that omits it, like
+     *  `alignment` and `scaledContents`. */
+    wordWrap?: boolean;
     /** Mudlet setLinkStyle(labelName, linkColor, linkVisitedColor, underline) —
      *  styling for `<a>` links inside the label's HTML. Cleared by
      *  resetLinkStyle. Colors are any CSS color string (empty = leave default). */

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

@@ -55,3 +55,4 @@ export declare function qtDeclarationsToCss(css: string, important?: boolean): s
 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;

package/dist-lib/ui/layout/ContentLayout.d.ts

@@ -16,4 +16,27 @@ interface ContentLayoutProps {
     vfs?: ProfileVFS | null;
 }
 export declare function ContentLayout({ session, manager, connectionId, stickyLines, commandInputRef, commandBar, contextMenuHandlerRef, scriptingEngineRef, vfs, }: ContentLayoutProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Holds the main console's DOM while a layout branch is on screen, and hands it
+ * back when that branch goes away.
+ *
+ * The console is mounted once, for the lifetime of ContentLayout, into a
+ * detached host div; the desktop tree and the phone tree each adopt that div
+ * rather than rendering an OutputArea of their own. Crossing the phone
+ * breakpoint therefore *moves* the console instead of destroying it.
+ *
+ * This is the same trick the content pool below uses for panels, and it is not
+ * a refinement: OutputArea's renderer appends lines imperatively into the
+ * wrapper it was handed at setup, and only ever appends *new* ones. Remounting
+ * it handed the renderer a fresh empty wrapper, so every line already on screen
+ * vanished while Console.history still held all of them — one resize across
+ * 600px emptied a session's scrollback with no way to bring it back.
+ *
+ * display:contents on the slot keeps the host in the parent's layout, so
+ * .main-viewport still measures and flexes exactly as it did before.
+ */
+export declare function ViewportSlot({ host, hidden }: {
+    host: HTMLDivElement;
+    hidden?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist-lib/ui/layout/MobileLayout.d.ts

@@ -4,6 +4,10 @@ import type { WindowManager } from '../windows/WindowManager';
 interface MobileLayoutProps {
     session: MudSession;
     manager: WindowManager;
+    /** The one main console, mounted by ContentLayout and adopted here — never
+     *  re-created, or the scrollback on screen would be lost on every
+     *  breakpoint crossing. See ViewportSlot. */
+    outputHost: HTMLDivElement;
     /** Already filtered to non-popped-out windows by ContentLayout. */
     windows: ScriptWindowRenderData[];
     stickyLines?: number;
@@ -18,5 +22,5 @@ interface MobileLayoutProps {
  * portal-target divs WindowManager already maintains (same trick as the
  * desktop TabGroupPanel), so panels stay live in the background.
  */
-export declare function MobileLayout({ session, manager, windows, stickyLines, commandInputRef, commandBar }: MobileLayoutProps): import("react/jsx-runtime").JSX.Element;
+export declare function MobileLayout({ manager, windows, outputHost, commandBar }: MobileLayoutProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist-lib/ui/output/OutputRenderer.d.ts

@@ -44,8 +44,6 @@ type OutputHandlerOptions = {
     stickyArea: HTMLElement;
     isSplitView: () => boolean;
     stickyLines: number;
-    maxElements?: number | (() => number);
-    trimSlack?: number;
     suppressSplitView?: (durationMs: number) => void;
     /** Whether new output should scroll the view to the tail. True for a
      *  scrollback; false for a console the writer rewrites wholesale — an MXP
@@ -66,5 +64,5 @@ export type OutputRendererControls = {
     push: (message: string | AnsiAwareBuffer, type?: string, timestamp?: number) => void;
     clear: () => void;
 };
-export declare function setupOutputRenderer(source: MessageSource | null, { outputWrapper, sentinel, stickyArea, isSplitView, stickyLines, maxElements, trimSlack, suppressSplitView, followTail, onCursorReady, }: OutputHandlerOptions): OutputRendererControls;
+export declare function setupOutputRenderer(source: MessageSource | null, { outputWrapper, sentinel, stickyArea, isSplitView, stickyLines, suppressSplitView, followTail, onCursorReady, }: OutputHandlerOptions): OutputRendererControls;
 export {};

package/dist-lib/ui/scrollbox/ScrollBoxOverlay.d.ts

@@ -1,11 +1,17 @@
 import type { ScrollBoxManager } from './ScrollBoxManager';
 import type { LabelManager } from '../labels/LabelManager';
 import type { CommandLineManager } from '../cmdline/CommandLineManager';
+import type { WindowManager } from '../windows/WindowManager';
 import './ScrollBoxOverlay.css';
 interface ScrollBoxOverlayProps {
     manager: ScrollBoxManager;
     labels: LabelManager;
     cmdLines: CommandLineManager;
+    /** Lets a box host the windows parented to it — Geyser.ScrollBox makes
+     *  itself the `windowname` of its children, so a mini-console created
+     *  inside one names the box as its parent. Optional only so a caller with
+     *  no WindowManager to hand still renders labels and command lines. */
+    windows?: WindowManager;
     /** Viewport whose scroll boxes this overlay renders ('main', a userwindow
      *  id, or — when nested — another scroll box's name). */
     parent: string;
@@ -14,12 +20,16 @@ interface ScrollBoxOverlayProps {
  * Renders the {@link ScrollBoxManager}'s boxes for a given parent viewport as
  * absolutely-positioned scrollable containers. Each box hosts the child overlays
  * (labels, command lines, and nested scroll boxes) scoped to the box's own name,
- * so widgets created with `parent = boxName` render inside it.
+ * so widgets created with `parent = boxName` render inside it. Each box also
+ * registers its scroll content as that name's overlay host, so mini-consoles
+ * and mappers created inside it portal into the box (see
+ * FloatingWindowLayer.resolveParent) instead of escaping to the document-wide
+ * floating root.
  *
  * Scrolling: the children are absolutely positioned and don't expand their
  * containers on their own, so each box wraps them in a content div sized to the
  * extent of its children (the furthest child edge). When that extent exceeds the
  * box, the box's `overflow:auto` produces real scrollbars.
  */
-export declare function ScrollBoxOverlay({ manager, labels, cmdLines, parent }: ScrollBoxOverlayProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function ScrollBoxOverlay({ manager, labels, cmdLines, windows, parent }: ScrollBoxOverlayProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist-lib/ui/windows/WindowManager.d.ts

@@ -38,6 +38,15 @@ export interface MapLoadProgress {
      */
     phase: 'rooms' | 'building';
 }
+/** Geometry of one window nested under a parent viewport — enough for a
+ *  container to size itself around its children (see subscribeChildWindows). */
+export interface NestedWindowGeometry {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
 export type WindowsChangedFn = (windows: ScriptWindowRenderData[], dockExtents: Record<DockSide, number>) => void;
 export declare class WindowManager {
     readonly overlayZ: OverlayLayerOrder;
@@ -49,6 +58,15 @@ export declare class WindowManager {
      *  from `elements` (the writable text/HTML target) so size queries report the
      *  full user-window box that labels live in, not the inner output area. */
     private readonly viewports;
+    /** Overlay hosts contributed by widgets that are containers but not
+     *  windows — today just Geyser.ScrollBox (see ScrollBoxOverlay). A scroll
+     *  box sets `windowname = its own name`, so mini-consoles created inside
+     *  it arrive here with the box's name as their parent and must portal into
+     *  the box's scroll content instead of escaping to the floating root. */
+    private readonly overlayHosts;
+    /** Per-parent subscribers wanting the geometry of the windows nested under
+     *  them — ScrollBoxOverlay sizes its scroll content to its children. */
+    private readonly childWindowListeners;
     private readonly lineBuffers;
     /** Per-window scroll/scrollbar overrides applied via CSS classes when the
      *  console's wrapper element registers. Mudlet's enable/disable Scrolling
@@ -257,6 +275,16 @@ export declare class WindowManager {
      *  context: `.main-overlay-root` for 'main', else the userwindow's own
      *  viewport (where its panel already renders the label overlays). */
     getOverlayHost(parentId: string): HTMLElement | null;
+    /** Registers a non-window overlay host (a scroll box's scroll content) so
+     *  windows parented to `id` portal into it. Notifies so a window that was
+     *  created before its host mounted gets re-homed on the next render. */
+    registerOverlayHost(id: string, element: HTMLElement): void;
+    unregisterOverlayHost(id: string, element?: HTMLElement): void;
+    /** Geometry of the visible windows nested under `parentId`. */
+    listChildWindows(parentId: string): NestedWindowGeometry[];
+    /** Subscribe to {@link listChildWindows} for one parent. Fires immediately
+     *  with the current list, like the label / cmd-line / scroll-box managers. */
+    subscribeChildWindows(parentId: string, fn: (children: NestedWindowGeometry[]) => void): () => void;
     register(id: string, element: HTMLElement, _kind: 'html'): void;
     pushBuffer(id: string, buffer: AnsiAwareBuffer): void;
     /** Push the current partial-line buffer (script echo without a trailing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mudlet/mudlet-web",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "type": "module",
   "description": "Mudlet Web — Mudlet in the browser, usable standalone or as a library for branded builds",
   "license": "GPL-2.0-or-later",
@@ -60,8 +60,8 @@
     "@codemirror/state": "^6.6.0",
     "@codemirror/theme-one-dark": "^6.1.3",
     "@codemirror/view": "^6.41.1",
+    "@lezer/highlight": "^1.2.3",
     "@sqlite.org/sqlite-wasm": "^3.53.0-build1",
-    "@types/dompurify": "^3.0.5",
     "@zenfs/core": "^2.5.6",
     "@zenfs/dom": "^1.2.9",
     "dompurify": "^3.4.14",