@flyingrobots/bijou-tui 7.1.0 → 8.0.0-rc.1

package/dist/overlay.js

@@ -1,630 +1,6 @@
-/**
- * Overlay compositing primitives for TUI apps.
- *
- * - `composite()` — paint overlays onto a background string (ANSI-safe)
- * - `compositeSurface()` — paint overlays onto a background surface
- * - `modal()` — centered dialog overlay with title, body, hint
- * - `toast()` — anchored notification overlay with variant icons
- * - `tooltip()` — positioned overlay relative to a target element
- */
-import { FLAG_DIM, FLAG_EMPTY } from '@flyingrobots/bijou';
-import { CELL_STRIDE, OFF_FLAGS, OFF_ALPHA, FLAG_BG_SET, parseHex, encodeModifiers } from '@flyingrobots/bijou/perf';
-import { createSurface, graphemeClusterWidth, isPackedSurface, parseAnsiToSurface, segmentGraphemes, shouldApplyBg, stripAnsi, surfaceToString, } from '@flyingrobots/bijou';
-import { sliceAnsi, visibleLength, clipToWidth } from './viewport.js';
-function resolvedColorRgb(ref) {
-    return typeof ref === 'object'
-        && ref !== null
-        && 'kind' in ref
-        && ref.kind === 'resolved-color'
-        && 'rgb' in ref
-        ? ref.rgb
-        : undefined;
-}
-function resolvedColorHex(ref) {
-    if (typeof ref === 'string')
-        return ref;
-    return typeof ref === 'object'
-        && ref !== null
-        && 'kind' in ref
-        && ref.kind === 'resolved-color'
-        && 'hex' in ref
-        ? ref.hex
-        : undefined;
-}
-import { clampCenteredPosition, resolveOverlayMargin } from './design-language.js';
-import { forceTextPresentation } from './icon-presentation.js';
-// ---------------------------------------------------------------------------
-// Border characters (same as core box.ts)
-// ---------------------------------------------------------------------------
-/** Unicode box-drawing characters for overlay borders. */
-const BORDER = {
-    tl: '\u250c', // ┌
-    tr: '\u2510', // ┐
-    bl: '\u2514', // └
-    br: '\u2518', // ┘
-    h: '\u2500', // ─
-    v: '\u2502', // │
-};
-// ---------------------------------------------------------------------------
-// spliceLine (internal)
-// ---------------------------------------------------------------------------
-/**
- * Splice an overlay line into a background line at a given column.
- *
- * Preserve background content to the left and right of the overlay,
- * inserting ANSI resets at splice boundaries.
- *
- * @param bgLine - Background line (may contain ANSI escapes).
- * @param overlayLine - Overlay line to paint over the background.
- * @param col - Starting visible column for the overlay (0-based).
- * @returns Merged line with the overlay replacing background characters.
- */
-function spliceLine(bgLine, overlayLine, col) {
-    const overlayVis = visibleLength(overlayLine);
-    const bgVis = visibleLength(bgLine);
-    const left = bgVis <= col
-        ? bgLine + ' '.repeat(col - bgVis)
-        : sliceAnsi(bgLine, 0, col);
-    const right = sliceAnsi(bgLine, col + overlayVis, bgVis);
-    return left + '\x1b[0m' + overlayLine + '\x1b[0m' + right;
-}
-// ---------------------------------------------------------------------------
-// composite()
-// ---------------------------------------------------------------------------
-/**
- * Paint one or more overlays onto a background string.
- *
- * Overlay content replaces background characters at the specified position.
- * Overlays are applied in array order (later overlays paint over earlier ones).
- * ANSI escape sequences are preserved correctly at splice boundaries.
- *
- * @param background - Background content string (newline-delimited).
- * @param overlays - Positioned overlays to composite onto the background.
- * @param options - Optional compositing settings (e.g., dim background).
- * @returns Composited string with all overlays applied.
- */
-export function composite(background, overlays, options) {
-    const bgLines = background.split('\n');
-    if (options?.dim) {
-        for (let i = 0; i < bgLines.length; i++) {
-            if (visibleLength(bgLines[i]) > 0) {
-                bgLines[i] = '\x1b[2m' + bgLines[i] + '\x1b[0m';
-            }
-        }
-    }
-    for (const overlay of overlays) {
-        const oLines = overlay.content.split('\n');
-        for (let i = 0; i < oLines.length; i++) {
-            const targetRow = overlay.row + i;
-            if (targetRow < 0 || targetRow >= bgLines.length)
-                continue;
-            bgLines[targetRow] = spliceLine(bgLines[targetRow], oLines[i], overlay.col);
-        }
-    }
-    return bgLines.join('\n');
-}
-/**
- * Paint one or more overlays onto a background surface.
- *
- * Overlays are applied in array order, with later overlays painting over
- * earlier ones. String-only overlays are normalized through an explicit
- * ANSI-to-surface bridge at the composition edge.
- */
-export function compositeSurface(background, overlays, options) {
-    const result = background.clone();
-    return compositeSurfaceInto(result, result, overlays, options);
-}
-/**
- * Paint overlays onto an existing target surface, optionally starting from an
- * existing background surface.
- *
- * When `background` and `target` are the same object, the surface is
- * composited in place without an extra clone.
- */
-export function compositeSurfaceInto(background, target, overlays, options) {
-    if (target !== background) {
-        target.clear();
-        target.blit(background, 0, 0);
-    }
-    if (options?.dim) {
-        const packed = isPackedSurface(target);
-        if (packed) {
-            // Fast path: set the dim flag bit directly in the buffer
-            const buf = target.buffer;
-            const size = target.width * target.height;
-            for (let i = 0; i < size; i++) {
-                const off = i * CELL_STRIDE;
-                if (buf[off + OFF_FLAGS] & FLAG_EMPTY)
-                    continue;
-                // Skip space chars (charCode 0x20)
-                if (buf[off] === 0x20 && buf[off + 1] === 0)
-                    continue;
-                buf[off + OFF_FLAGS] = buf[off + OFF_FLAGS] | FLAG_DIM;
-            }
-            target.markAllDirty();
-        }
-        else {
-            for (let y = 0; y < target.height; y++) {
-                for (let x = 0; x < target.width; x++) {
-                    const cell = target.get(x, y);
-                    if (cell.empty || cell.char === ' ')
-                        continue;
-                    const modifiers = cell.modifiers ?? [];
-                    if (!modifiers.includes('dim')) {
-                        target.set(x, y, { ...cell, modifiers: [...modifiers, 'dim'], empty: false });
-                    }
-                }
-            }
-        }
-    }
-    for (const overlay of overlays) {
-        target.blit(overlay.surface ?? surfaceFromContent(overlay.content), overlay.col, overlay.row);
-    }
-    return target;
-}
-function styleFromToken(token, ctx) {
-    if (!ctx || token == null)
-        return {};
-    const style = {
-        fg: token.hex,
-        bg: token.bg,
-        modifiers: token.modifiers ? [...token.modifiers] : undefined,
-    };
-    if (token.fgRGB)
-        style.fgRGB = token.fgRGB;
-    if (token.bgRGB)
-        style.bgRGB = token.bgRGB;
-    return style;
-}
-function backgroundStyleFromToken(token, ctx) {
-    if (!ctx || !shouldApplyBg(ctx) || !token?.bg)
-        return {};
-    const style = { bg: token.bg };
-    if (token.bgRGB)
-        style.bgRGB = token.bgRGB;
-    return style;
-}
-function mergeStyles(base, extra) {
-    const modifiers = [...(base.modifiers ?? []), ...(extra.modifiers ?? [])];
-    const fg = extra.fg ?? base.fg;
-    const bg = extra.bg ?? base.bg;
-    return {
-        fg,
-        bg,
-        // When extra.fg overrides base.fg, use extra's fgRGB (may be
-        // undefined — correctly clearing the pre-parsed cache so the
-        // differ falls back to inlineHexRGB for the new hex string).
-        // When extra.fg is absent, inherit base's fgRGB if available.
-        fgRGB: extra.fg != null ? extra.fgRGB : (extra.fgRGB ?? base.fgRGB),
-        bgRGB: extra.bg != null ? extra.bgRGB : (extra.bgRGB ?? base.bgRGB),
-        modifiers: modifiers.length > 0 ? Array.from(new Set(modifiers)) : undefined,
-    };
-}
-function plainSurfaceToString(surface) {
-    const lines = [];
-    for (let y = 0; y < surface.height; y++) {
-        let line = '';
-        for (let x = 0; x < surface.width; x++) {
-            line += surface.get(x, y).char;
-        }
-        lines.push(line);
-    }
-    return lines.join('\n');
-}
-function overlayContentFromSurface(surface, ctx) {
-    return ctx ? surfaceToString(surface, ctx.style) : plainSurfaceToString(surface);
-}
-function setStyledCell(surface, x, y, char, style, numStyle) {
-    if (numStyle && isPackedSurface(surface)) {
-        surface.setRGB(x, y, char, numStyle.fR, numStyle.fG, numStyle.fB, numStyle.bR, numStyle.bG, numStyle.bB, numStyle.fl);
-    }
-    else {
-        surface.set(x, y, { char, ...style, empty: false });
-    }
-}
-function setStyledGrapheme(surface, x, y, char, style, numStyle) {
-    if (x >= surface.width)
-        return 0;
-    const width = Math.max(1, graphemeClusterWidth(char));
-    setStyledCell(surface, x, y, char, style, numStyle);
-    for (let offset = 1; offset < width && x + offset < surface.width; offset++) {
-        setStyledCell(surface, x + offset, y, '', style);
-    }
-    return width;
-}
-function lineSurface(text, style = {}) {
-    if (text.length === 0)
-        return createSurface(0, 1);
-    const plain = stripAnsi(text);
-    const width = Math.max(0, visibleLength(text));
-    if (width === 0)
-        return createSurface(0, 1);
-    if (plain !== text && style.fg == null && style.bg == null && style.modifiers == null) {
-        return parseAnsiToSurface(text, width, 1);
-    }
-    const graphemes = segmentGraphemes(plain);
-    const surface = createSurface(width, 1);
-    // Pre-parse style for setRGB fast path
-    let ns;
-    if (isPackedSurface(surface)) {
-        let fR = -1, fG = 0, fB = 0, bR = -1, bG = 0, bB = 0;
-        const fgHex = resolvedColorHex(style.fg);
-        const fgRgb = style.fgRGB ?? resolvedColorRgb(style.fg) ?? (fgHex ? parseHex(fgHex) : undefined);
-        if (fgRgb) {
-            [fR, fG, fB] = fgRgb;
-        }
-        const bgHex = resolvedColorHex(style.bg);
-        const bgRgb = style.bgRGB ?? resolvedColorRgb(style.bg) ?? (bgHex ? parseHex(bgHex) : undefined);
-        if (bgRgb) {
-            [bR, bG, bB] = bgRgb;
-        }
-        ns = { fR, fG, fB, bR, bG, bB, fl: style.modifiers ? encodeModifiers(style.modifiers) : 0 };
-    }
-    let x = 0;
-    for (const grapheme of graphemes) {
-        if (x >= width)
-            break;
-        x += setStyledGrapheme(surface, x, 0, grapheme, style, ns);
-    }
-    return surface;
-}
-function lineWithInheritedBackground(line, style) {
-    if ((style.bg == null && style.bgRGB == null) || line.width === 0)
-        return line;
-    const result = line.clone();
-    // Fast path: packed surface — write bg bytes directly
-    const packedSurface = isPackedSurface(result) ? result : undefined;
-    const bgHex = resolvedColorHex(style.bg);
-    const rgb = packedSurface
-        ? (style.bgRGB ?? resolvedColorRgb(style.bg) ?? (bgHex ? parseHex(bgHex) : undefined))
-        : undefined;
-    if (packedSurface && rgb) {
-        const [bgR, bgG, bgB] = rgb;
-        const buf = packedSurface.buffer;
-        for (let i = 0; i < result.width; i++) {
-            const off = i * CELL_STRIDE;
-            if (buf[off + OFF_FLAGS] & FLAG_EMPTY)
-                continue;
-            if (buf[off + OFF_ALPHA] & FLAG_BG_SET)
-                continue;
-            buf[off + 5] = bgR;
-            buf[off + 6] = bgG;
-            buf[off + 7] = bgB;
-            buf[off + OFF_ALPHA] = buf[off + OFF_ALPHA] | FLAG_BG_SET;
-        }
-        packedSurface.markAllDirty();
-        return result;
-    }
-    for (let x = 0; x < result.width; x++) {
-        const cell = result.get(x, 0);
-        if (cell.empty)
-            continue;
-        result.set(x, 0, {
-            ...cell,
-            bg: cell.bg ?? style.bg,
-            bgRGB: cell.bgRGB ?? style.bgRGB,
-            empty: false,
-        });
-    }
-    return result;
-}
-function surfaceRows(surface, maxWidth) {
-    const width = maxWidth != null ? Math.max(0, Math.min(surface.width, maxWidth)) : surface.width;
-    if (surface.height <= 0)
-        return [createSurface(width, 1)];
-    const rows = [];
-    for (let y = 0; y < surface.height; y++) {
-        const row = createSurface(width, 1);
-        if (width > 0)
-            row.blit(surface, 0, 0, 0, y, width, 1);
-        rows.push(row);
-    }
-    return rows;
-}
-function contentLines(content, maxWidth) {
-    if (typeof content === 'string') {
-        return content.split('\n').map((line) => lineSurface(maxWidth != null ? clipToWidth(line, maxWidth) : line));
-    }
-    return surfaceRows(content, maxWidth);
-}
-function renderBoxSurface(lines, borderStyle, fillStyle, innerWidthOverride) {
-    const innerWidth = innerWidthOverride ?? lines.reduce((max, line) => Math.max(max, line.width), 0);
-    const width = innerWidth + 4;
-    const height = lines.length + 2;
-    const surface = createSurface(width, height);
-    setStyledCell(surface, 0, 0, BORDER.tl, borderStyle);
-    for (let x = 1; x < width - 1; x++)
-        setStyledCell(surface, x, 0, BORDER.h, borderStyle);
-    setStyledCell(surface, width - 1, 0, BORDER.tr, borderStyle);
-    setStyledCell(surface, 0, height - 1, BORDER.bl, borderStyle);
-    for (let x = 1; x < width - 1; x++)
-        setStyledCell(surface, x, height - 1, BORDER.h, borderStyle);
-    setStyledCell(surface, width - 1, height - 1, BORDER.br, borderStyle);
-    for (let i = 0; i < lines.length; i++) {
-        const y = i + 1;
-        setStyledCell(surface, 0, y, BORDER.v, borderStyle);
-        for (let x = 1; x < width - 1; x++)
-            setStyledCell(surface, x, y, ' ', fillStyle);
-        setStyledCell(surface, width - 1, y, BORDER.v, borderStyle);
-        const line = lineWithInheritedBackground(lines[i], fillStyle);
-        if (line.width > 0 && innerWidth > 0) {
-            surface.blit(line, 2, y, 0, 0, Math.min(line.width, innerWidth), 1);
-        }
-    }
-    return surface;
-}
-// ---------------------------------------------------------------------------
-// modal()
-// ---------------------------------------------------------------------------
-/**
- * Create a centered modal dialog overlay.
- *
- * Build a bordered box with optional title, body, and hint text,
- * then center it on screen.
- *
- * @param options - Modal configuration including content and screen dimensions.
- * @returns Overlay positioned at the center of the screen.
- */
-export function modal(options) {
-    const { title, body, hint, screenWidth, screenHeight, ctx } = options;
-    const lines = [];
-    if (title != null) {
-        lines.push(lineSurface(title, ctx ? { modifiers: ['bold'] } : {}), createSurface(0, 1));
-    }
-    lines.push(...contentLines(body));
-    if (hint != null) {
-        lines.push(createSurface(0, 1));
-        if (typeof hint === 'string') {
-            lines.push(lineSurface(hint, styleFromToken(ctx?.semantic('muted'), ctx)));
-        }
-        else {
-            lines.push(...surfaceRows(hint));
-        }
-    }
-    const surface = renderBoxSurface(lines, styleFromToken(options.borderToken, ctx), backgroundStyleFromToken(options.bgToken, ctx), options.width != null ? Math.max(0, options.width - 4) : undefined);
-    const margin = resolveOverlayMargin(screenWidth, screenHeight, options.margin);
-    const row = clampCenteredPosition(screenHeight, surface.height, margin);
-    const col = clampCenteredPosition(screenWidth, surface.width, margin);
-    return { content: overlayContentFromSurface(surface, ctx), surface, row, col };
-}
-// ---------------------------------------------------------------------------
-// toast()
-// ---------------------------------------------------------------------------
-/** Unicode icon characters mapped by toast variant. */
-const TOAST_ICONS = {
-    success: forceTextPresentation('\u2714'), // ✔
-    error: forceTextPresentation('\u2718'), // ✘
-    info: forceTextPresentation('\u2139'), // ℹ
-};
-/** Semantic border token keys mapped by toast variant. */
-const TOAST_BORDER = {
-    success: 'success',
-    error: 'error',
-    info: 'primary',
-};
-/**
- * Create an anchored toast notification overlay.
- *
- * Render a bordered box with a variant icon and message, positioned
- * at the specified screen corner with configurable margin.
- *
- * @param options - Toast configuration including message, variant, and screen dimensions.
- * @returns Overlay positioned at the specified screen corner.
- */
-export function toast(options) {
-    const { message, variant = 'info', anchor = 'bottom-right', screenWidth, screenHeight, margin, ctx, } = options;
-    const resolvedMargin = resolveOverlayMargin(screenWidth, screenHeight, margin);
-    const icon = TOAST_ICONS[variant];
-    const line = lineSurface(`${icon} ${message}`, styleFromToken(ctx?.semantic(variant), ctx));
-    const surface = renderBoxSurface([line], styleFromToken(ctx?.border(TOAST_BORDER[variant]), ctx), backgroundStyleFromToken(options.bgToken, ctx));
-    let row;
-    let col;
-    switch (anchor) {
-        case 'top-right':
-            row = resolvedMargin;
-            col = screenWidth - surface.width - resolvedMargin;
-            break;
-        case 'bottom-right':
-            row = screenHeight - surface.height - resolvedMargin;
-            col = screenWidth - surface.width - resolvedMargin;
-            break;
-        case 'bottom-left':
-            row = screenHeight - surface.height - resolvedMargin;
-            col = resolvedMargin;
-            break;
-        case 'top-left':
-            row = resolvedMargin;
-            col = resolvedMargin;
-            break;
-    }
-    row = Math.max(0, row);
-    col = Math.max(0, col);
-    return { content: overlayContentFromSurface(surface, ctx), surface, row, col };
-}
-// ---------------------------------------------------------------------------
-// drawer()
-// ---------------------------------------------------------------------------
-/**
- * Create a drawer overlay anchored to a screen edge.
- *
- * Supports horizontal anchors (`left`/`right`) that span the full screen height,
- * and vertical anchors (`top`/`bottom`) that span the full screen width.
- * Defaults to the right edge when no anchor is specified.
- * Renders a bordered panel with optional title in the top border.
- *
- * When an optional `region` is provided, the drawer is constrained to that
- * sub-region rectangle instead of spanning the full screen dimensions.
- *
- * @param options - Drawer configuration including content, anchor, and dimensions.
- * @returns Overlay positioned at the specified screen edge.
- */
-export function drawer(options) {
-    const { content, screenWidth, screenHeight, title, ctx, } = options;
-    const region = clampRegion(options.region, screenWidth, screenHeight);
-    const dims = resolveDrawerDimensions(options, region);
-    const { width, height, row, col } = dims;
-    const innerWidth = Math.max(0, width - 4); // border + padding on each side
-    const borderStyle = styleFromToken(options.borderToken, ctx);
-    const fillStyle = backgroundStyleFromToken(options.bgToken, ctx);
-    const titleStyle = ctx ? { modifiers: ['bold'] } : {};
-    const surface = createSurface(width, height);
-    if (width === 0 || height === 0) {
-        return { content: overlayContentFromSurface(surface, ctx), surface, row, col };
-    }
-    for (let x = 0; x < width; x++) {
-        const topChar = x === 0 ? BORDER.tl : x === width - 1 ? BORDER.tr : BORDER.h;
-        setStyledCell(surface, x, 0, topChar, borderStyle);
-        if (height > 1) {
-            const bottomChar = x === 0 ? BORDER.bl : x === width - 1 ? BORDER.br : BORDER.h;
-            setStyledCell(surface, x, height - 1, bottomChar, borderStyle);
-        }
-    }
-    if (title != null && width > 2) {
-        const titleLine = lineSurface(title, titleStyle);
-        const spanWidth = Math.min(width - 2, titleLine.width + 2);
-        const startX = 1 + Math.max(0, Math.floor(((width - 2) - spanWidth) / 2));
-        setStyledCell(surface, startX, 0, ' ', borderStyle);
-        const mergedTitleStyle = mergeStyles(borderStyle, titleStyle);
-        for (let x = 0; x < Math.min(titleLine.width, Math.max(0, spanWidth - 2)); x++) {
-            setStyledCell(surface, startX + 1 + x, 0, titleLine.get(x, 0).char, mergedTitleStyle);
-        }
-        if (spanWidth >= 2) {
-            setStyledCell(surface, startX + spanWidth - 1, 0, ' ', borderStyle);
-        }
-    }
-    const rows = contentLines(content, innerWidth);
-    const availableHeight = Math.max(0, height - 2);
-    for (let i = 0; i < availableHeight; i++) {
-        const y = i + 1;
-        if (width >= 1)
-            setStyledCell(surface, 0, y, BORDER.v, borderStyle);
-        for (let x = 1; x < Math.max(1, width - 1); x++) {
-            if (x < width - 1)
-                setStyledCell(surface, x, y, ' ', fillStyle);
-        }
-        if (width >= 2)
-            setStyledCell(surface, width - 1, y, BORDER.v, borderStyle);
-        const line = lineWithInheritedBackground(rows[i] ?? createSurface(0, 1), fillStyle);
-        if (line.width > 0 && innerWidth > 0 && width >= 4) {
-            surface.blit(line, 2, y, 0, 0, Math.min(line.width, innerWidth), 1);
-        }
-    }
-    return {
-        content: overlayContentFromSurface(surface, ctx),
-        surface,
-        row,
-        col,
-    };
-}
-/** Compute the final width, height, row, and col for a drawer given its anchor. */
-function resolveDrawerDimensions(options, region) {
-    if (options.anchor === 'top' || options.anchor === 'bottom') {
-        const anchor = options.anchor;
-        const heightRaw = options.height;
-        if (heightRaw == null || !Number.isFinite(heightRaw)) {
-            throw new Error(`drawer(): "height" is required for anchor "${anchor}"`);
-        }
-        const height = clamp(Math.floor(heightRaw), 0, region.height);
-        const width = region.width;
-        const col = region.col;
-        const row = anchor === 'top'
-            ? region.row
-            : region.row + region.height - height;
-        return { width, height, row: Math.max(region.row, row), col };
-    }
-    const anchor = options.anchor ?? 'right';
-    if (anchor === 'left' || anchor === 'right') {
-        const widthRaw = options.width;
-        if (widthRaw == null || !Number.isFinite(widthRaw)) {
-            throw new Error(`drawer(): "width" is required for anchor "${anchor}"`);
-        }
-        const width = clamp(Math.floor(widthRaw), 0, region.width);
-        const height = region.height;
-        const row = region.row;
-        const col = anchor === 'left'
-            ? region.col
-            : region.col + region.width - width;
-        return { width, height, row, col: Math.max(region.col, col) };
-    }
-    return assertNever(anchor);
-}
-/** Exhaustive check — always throws. */
-function assertNever(value) {
-    throw new Error(`Unexpected drawer anchor: ${String(value)}`);
-}
-/** Normalize an optional region into a clamped LayoutRect within screen bounds. */
-function clampRegion(region, screenWidth, screenHeight) {
-    const sw = Math.floor(screenWidth);
-    const sh = Math.floor(screenHeight);
-    if (region == null) {
-        return {
-            row: 0,
-            col: 0,
-            width: Math.floor(Math.max(0, sw)),
-            height: Math.floor(Math.max(0, sh)),
-        };
-    }
-    const row = Math.floor(clamp(region.row, 0, Math.max(0, sh)));
-    const col = Math.floor(clamp(region.col, 0, Math.max(0, sw)));
-    const maxWidth = Math.max(0, sw - col);
-    const maxHeight = Math.max(0, sh - row);
-    return {
-        row,
-        col,
-        width: Math.floor(clamp(region.width, 0, maxWidth)),
-        height: Math.floor(clamp(region.height, 0, maxHeight)),
-    };
-}
-/** Clamp a number between min and max. */
-function clamp(value, min, max) {
-    return Math.max(min, Math.min(max, value));
-}
-// ---------------------------------------------------------------------------
-// tooltip()
-// ---------------------------------------------------------------------------
-/**
- * Create a tooltip overlay positioned relative to a target element.
- *
- * Render a bordered box containing the content, placed in the specified
- * direction from the target. Clamp to screen bounds to prevent overflow.
- *
- * @param options - Tooltip configuration including content, target position, and direction.
- * @returns Overlay positioned relative to the target, clamped to screen bounds.
- */
-export function tooltip(options) {
-    const { content, row: targetRow, col: targetCol, direction = 'top', screenWidth, screenHeight, borderToken, bgToken, ctx, } = options;
-    const maxContentWidth = Math.max(0, screenWidth - 4);
-    const lines = contentLines(content, maxContentWidth);
-    const surface = renderBoxSurface(lines, styleFromToken(borderToken, ctx), backgroundStyleFromToken(bgToken, ctx));
-    let tipRow;
-    let tipCol;
-    switch (direction) {
-        case 'top':
-            tipRow = targetRow - surface.height;
-            tipCol = targetCol - Math.floor(surface.width / 2);
-            break;
-        case 'bottom':
-            tipRow = targetRow + 1;
-            tipCol = targetCol - Math.floor(surface.width / 2);
-            break;
-        case 'left':
-            tipRow = targetRow - Math.floor(surface.height / 2);
-            tipCol = targetCol - surface.width;
-            break;
-        case 'right':
-            tipRow = targetRow - Math.floor(surface.height / 2);
-            tipCol = targetCol + 1;
-            break;
-    }
-    // Clamp to screen bounds
-    tipRow = Math.max(0, Math.min(tipRow, screenHeight - surface.height));
-    tipCol = Math.max(0, Math.min(tipCol, screenWidth - surface.width));
-    return { content: overlayContentFromSurface(surface, ctx), surface, row: tipRow, col: tipCol };
-}
-function surfaceFromContent(content) {
-    const lines = content.split('\n');
-    const width = Math.max(1, ...lines.map((line) => visibleLength(line)));
-    const height = Math.max(1, lines.length);
-    return parseAnsiToSurface(content, width, height);
-}
+export { composite, compositeSurface, compositeSurfaceInto } from './overlay.part02.js';
+export { modal } from './overlay.part05.js';
+export { toast } from './overlay.part06.js';
+export { drawer } from './overlay.part07.js';
+export { tooltip } from './overlay.part09.js';
 //# sourceMappingURL=overlay.js.map