@andorra-labs/code 0.0.0-stage → 0.1.4

package/dist/vendor/engine/runtime/tui/components/settings-list.js

@@ -0,0 +1,251 @@
+import { andorraFuzzyFilter } from "../fuzzy.js";
+import { andorraGetKeybindings } from "../keybindings.js";
+import { andorraTruncateToWidth, andorraVisibleWidth, andorraWrapTextWithAnsi } from "../utils.js";
+import { AndorraInput } from "./input.js";
+export class AndorraSettingsList {
+    items;
+    filteredItems;
+    theme;
+    selectedIndex = 0;
+    mousePressedIndex;
+    maxVisible;
+    onChange;
+    onCancel;
+    searchInput;
+    searchEnabled;
+    // Submenu state
+    submenuComponent = null;
+    submenuItemIndex = null;
+    navigateAfterClose = null;
+    constructor(items, maxVisible, theme, onChange, onCancel, options = {}) {
+        this.items = items;
+        this.filteredItems = items;
+        this.maxVisible = maxVisible;
+        this.theme = theme;
+        this.onChange = onChange;
+        this.onCancel = onCancel;
+        this.searchEnabled = options.enableSearch ?? false;
+        if (this.searchEnabled) {
+            this.searchInput = new AndorraInput();
+        }
+    }
+    /** Update an item's currentValue */
+    updateValue(id, newValue) {
+        const item = this.items.find((i) => i.id === id);
+        if (item) {
+            item.currentValue = newValue;
+        }
+    }
+    /** Move selection to the item with the given id (no-op if not found). */
+    selectItem(id) {
+        const items = this.searchEnabled ? this.filteredItems : this.items;
+        const index = items.findIndex((i) => i.id === id);
+        if (index !== -1) {
+            this.selectedIndex = index;
+        }
+    }
+    invalidate() {
+        this.submenuComponent?.invalidate?.();
+    }
+    render(width) {
+        // If submenu is active, render it instead
+        if (this.submenuComponent) {
+            return this.submenuComponent.render(width);
+        }
+        return this.renderMainList(width);
+    }
+    renderMainList(width) {
+        const lines = [];
+        if (this.searchEnabled && this.searchInput) {
+            lines.push(...this.searchInput.render(width));
+            lines.push("");
+        }
+        if (this.items.length === 0) {
+            lines.push(this.theme.hint("  No settings available"));
+            if (this.searchEnabled) {
+                this.addHintLine(lines, width);
+            }
+            return lines;
+        }
+        const displayItems = this.getDisplayItems();
+        if (displayItems.length === 0) {
+            lines.push(andorraTruncateToWidth(this.theme.hint("  No matching settings"), width));
+            this.addHintLine(lines, width);
+            return lines;
+        }
+        // Calculate visible range with scrolling
+        const { startIndex, endIndex } = this.getVisibleRange(displayItems);
+        // Calculate max label width for alignment
+        const maxLabelWidth = Math.min(36, Math.max(...this.items.map((item) => andorraVisibleWidth(item.label))));
+        // Render visible items
+        for (let i = startIndex; i < endIndex; i++) {
+            const item = displayItems[i];
+            if (!item)
+                continue;
+            const isSelected = i === this.selectedIndex;
+            const prefix = isSelected ? this.theme.cursor : "  ";
+            const prefixWidth = andorraVisibleWidth(prefix);
+            // Pad label to align values
+            const labelPadded = item.label + " ".repeat(Math.max(0, maxLabelWidth - andorraVisibleWidth(item.label)));
+            const labelText = this.theme.label(labelPadded, isSelected);
+            // Calculate space for value
+            const separator = "  ";
+            const usedWidth = prefixWidth + maxLabelWidth + andorraVisibleWidth(separator);
+            const valueMaxWidth = width - usedWidth - 2;
+            const valueText = this.theme.value(andorraTruncateToWidth(item.currentValue, valueMaxWidth, ""), isSelected);
+            lines.push(andorraTruncateToWidth(prefix + labelText + separator + valueText, width));
+        }
+        // Add scroll indicator if needed
+        if (startIndex > 0 || endIndex < displayItems.length) {
+            const scrollText = `  (${this.selectedIndex + 1}/${displayItems.length})`;
+            lines.push(this.theme.hint(andorraTruncateToWidth(scrollText, width - 2, "")));
+        }
+        // Add description for selected item
+        const selectedItem = displayItems[this.selectedIndex];
+        if (selectedItem?.description) {
+            lines.push("");
+            const wrappedDesc = andorraWrapTextWithAnsi(selectedItem.description, width - 4);
+            for (const line of wrappedDesc) {
+                lines.push(this.theme.description(`  ${line}`));
+            }
+        }
+        // Add hint
+        this.addHintLine(lines, width);
+        return lines;
+    }
+    handleMouse(event) {
+        if (this.submenuComponent) {
+            const result = this.submenuComponent.handleMouse?.(event);
+            return result ? { ...result, focus: true } : undefined;
+        }
+        if (this.searchEnabled && this.searchInput) {
+            if (event.y === 0) {
+                const result = this.searchInput.handleMouse?.(event);
+                return result ? { ...result, focus: true } : undefined;
+            }
+            if (event.y === 1)
+                return undefined;
+        }
+        const displayItems = this.getDisplayItems();
+        if (displayItems.length === 0)
+            return undefined;
+        if (event.type === "wheel" && event.wheelDelta) {
+            const delta = event.wheelDelta < 0 ? -1 : 1;
+            const previousIndex = this.selectedIndex;
+            this.selectedIndex = Math.max(0, Math.min(displayItems.length - 1, this.selectedIndex + delta));
+            return { handled: true, render: this.selectedIndex !== previousIndex };
+        }
+        // Hover must not change selection: the visible range is centered on it.
+        if (event.button !== "left" || (event.type !== "press" && event.type !== "click"))
+            return undefined;
+        const rowOffset = this.searchEnabled ? 2 : 0;
+        const { startIndex, endIndex } = this.getVisibleRange(displayItems);
+        const itemIndex = startIndex + event.y - rowOffset;
+        if (itemIndex < startIndex || itemIndex >= endIndex)
+            return undefined;
+        if (event.type === "press") {
+            this.mousePressedIndex = itemIndex;
+            this.selectedIndex = itemIndex;
+            return { handled: true, focus: true };
+        }
+        if (event.type === "click") {
+            this.selectedIndex = this.mousePressedIndex ?? itemIndex;
+            this.mousePressedIndex = undefined;
+            this.activateItem();
+            return { handled: true };
+        }
+        return undefined;
+    }
+    handleInput(data) {
+        // If submenu is active, delegate all input to it
+        // The submenu's onCancel (triggered by escape) will call done() which closes it
+        if (this.submenuComponent) {
+            this.submenuComponent.handleInput?.(data);
+            return;
+        }
+        // Main list input handling
+        const kb = andorraGetKeybindings();
+        const displayItems = this.getDisplayItems();
+        if (kb.matches(data, "tui.select.up")) {
+            if (displayItems.length === 0)
+                return;
+            this.selectedIndex = this.selectedIndex === 0 ? displayItems.length - 1 : this.selectedIndex - 1;
+        }
+        else if (kb.matches(data, "tui.select.down")) {
+            if (displayItems.length === 0)
+                return;
+            this.selectedIndex = this.selectedIndex === displayItems.length - 1 ? 0 : this.selectedIndex + 1;
+        }
+        else if (kb.matches(data, "tui.select.confirm") ||
+            (data === " " && (!this.searchEnabled || this.searchInput?.getValue().length === 0))) {
+            this.activateItem();
+        }
+        else if (kb.matches(data, "tui.select.cancel")) {
+            this.onCancel();
+        }
+        else if (this.searchEnabled && this.searchInput) {
+            this.searchInput.handleInput(data);
+            this.applyFilter(this.searchInput.getValue());
+        }
+    }
+    getDisplayItems() {
+        return this.searchEnabled ? this.filteredItems : this.items;
+    }
+    getVisibleRange(displayItems) {
+        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), displayItems.length - this.maxVisible));
+        return { startIndex, endIndex: Math.min(startIndex + this.maxVisible, displayItems.length) };
+    }
+    activateItem() {
+        const item = this.getDisplayItems()[this.selectedIndex];
+        if (!item)
+            return;
+        if (item.submenu) {
+            // Open submenu, passing current value so it can pre-select correctly
+            this.submenuItemIndex = this.selectedIndex;
+            this.submenuComponent = item.submenu(item.currentValue, (selectedValue, options) => {
+                if (selectedValue !== undefined) {
+                    item.currentValue = selectedValue;
+                    this.onChange(item.id, selectedValue);
+                }
+                if (options?.navigateTo) {
+                    this.navigateAfterClose = options.navigateTo;
+                }
+                this.closeSubmenu();
+            });
+        }
+        else if (item.values && item.values.length > 0) {
+            // Cycle through values
+            const currentIndex = item.values.indexOf(item.currentValue);
+            const nextIndex = (currentIndex + 1) % item.values.length;
+            const newValue = item.values[nextIndex];
+            item.currentValue = newValue;
+            this.onChange(item.id, newValue);
+        }
+    }
+    closeSubmenu() {
+        this.submenuComponent = null;
+        if (this.navigateAfterClose !== null) {
+            const id = this.navigateAfterClose;
+            this.navigateAfterClose = null;
+            this.submenuItemIndex = null;
+            this.selectItem(id);
+            // Open the target item's submenu automatically
+            this.activateItem();
+        }
+        else if (this.submenuItemIndex !== null) {
+            // Restore selection to the item that opened the submenu
+            this.selectedIndex = this.submenuItemIndex;
+            this.submenuItemIndex = null;
+        }
+    }
+    applyFilter(query) {
+        this.filteredItems = andorraFuzzyFilter(this.items, query, (item) => item.label);
+        this.selectedIndex = 0;
+    }
+    addHintLine(lines, width) {
+        lines.push("");
+        lines.push(andorraTruncateToWidth(this.theme.hint(this.searchEnabled
+            ? "  Type to search · Enter/Space to change · Esc to cancel"
+            : "  Enter/Space to change · Esc to cancel"), width));
+    }
+}

package/dist/vendor/engine/runtime/tui/components/spacer.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from "../tui.js";
+/**
+ * Spacer component that renders empty lines
+ */
+export declare class AndorraSpacer implements Component {
+    private lines;
+    constructor(lines?: number);
+    setLines(lines: number): void;
+    invalidate(): void;
+    render(_width: number): string[];
+}

package/dist/vendor/engine/runtime/tui/components/spacer.js

@@ -0,0 +1,22 @@
+/**
+ * Spacer component that renders empty lines
+ */
+export class AndorraSpacer {
+    lines;
+    constructor(lines = 1) {
+        this.lines = lines;
+    }
+    setLines(lines) {
+        this.lines = lines;
+    }
+    invalidate() {
+        // No cached state to invalidate currently
+    }
+    render(_width) {
+        const result = [];
+        for (let i = 0; i < this.lines; i++) {
+            result.push("");
+        }
+        return result;
+    }
+}

package/dist/vendor/engine/runtime/tui/components/stack.d.ts

@@ -0,0 +1,31 @@
+import { LAYOUT_NODE, type LayoutViewport, type StackLayoutEntry, type StackLayoutNode } from "../layout-node.js";
+import { type Component, AndorraContainer } from "../tui.js";
+export interface StackEntryOptions {
+    basis?: number | "auto";
+    grow?: number;
+    shrink?: number;
+    minSize?: number;
+    maxSize?: number;
+    visible?: (viewport: LayoutViewport) => boolean;
+}
+export interface StackEntry extends StackEntryOptions {
+    component: Component;
+}
+export type StackChild = Component | StackEntry;
+export interface StackOptions {
+    gap?: number;
+    align?: "stretch" | "start" | "center" | "end";
+}
+export declare abstract class AndorraStack extends AndorraContainer {
+    protected readonly entries: StackLayoutEntry[];
+    protected readonly gap: number;
+    protected readonly align: "stretch" | "start" | "center" | "end";
+    protected abstract readonly layoutType: "vstack" | "hstack";
+    constructor(children?: StackChild[], options?: StackOptions);
+    addChild(component: Component, options?: StackEntryOptions): void;
+    removeChild(component: Component): void;
+    clear(): void;
+    [LAYOUT_NODE](): StackLayoutNode;
+}
+export declare function andorraVisibleStackEntries(entries: readonly StackLayoutEntry[], viewport: LayoutViewport): StackLayoutEntry[];
+export declare function andorraAllocateStackSizes(entries: readonly StackLayoutEntry[], intrinsicSizes: readonly number[], availableSize: number | undefined, gap: number): number[];

package/dist/vendor/engine/runtime/tui/components/stack.js

@@ -0,0 +1,110 @@
+import { LAYOUT_NODE } from "../layout-node.js";
+import { AndorraContainer } from "../tui.js";
+function andorraIsStackEntry(child) {
+    return !("render" in child);
+}
+function andorraNormalizeSize(value, fallback) {
+    return value === undefined || !Number.isFinite(value) ? fallback : Math.max(0, Math.floor(value));
+}
+export class AndorraStack extends AndorraContainer {
+    entries = [];
+    gap;
+    align;
+    constructor(children = [], options = {}) {
+        super();
+        this.gap = andorraNormalizeSize(options.gap, 0);
+        this.align = options.align ?? "stretch";
+        for (const child of children) {
+            if (andorraIsStackEntry(child))
+                this.addChild(child.component, child);
+            else
+                this.addChild(child);
+        }
+    }
+    addChild(component, options = {}) {
+        super.addChild(component);
+        this.entries.push({
+            component,
+            ...(options.basis === undefined ? {} : { basis: options.basis }),
+            ...(options.grow === undefined ? {} : { grow: andorraNormalizeSize(options.grow, 0) }),
+            ...(options.shrink === undefined ? {} : { shrink: andorraNormalizeSize(options.shrink, 1) }),
+            ...(options.minSize === undefined ? {} : { minSize: andorraNormalizeSize(options.minSize, 0) }),
+            ...(options.maxSize === undefined ? {} : { maxSize: andorraNormalizeSize(options.maxSize, Number.MAX_SAFE_INTEGER) }),
+            ...(options.visible === undefined ? {} : { visible: options.visible }),
+        });
+    }
+    removeChild(component) {
+        super.removeChild(component);
+        const index = this.entries.findIndex((entry) => entry.component === component);
+        if (index !== -1)
+            this.entries.splice(index, 1);
+    }
+    clear() {
+        super.clear();
+        this.entries.length = 0;
+    }
+    [LAYOUT_NODE]() {
+        return {
+            type: this.layoutType,
+            entries: this.entries,
+            gap: this.gap,
+            align: this.align,
+        };
+    }
+}
+export function andorraVisibleStackEntries(entries, viewport) {
+    return entries.filter((entry) => entry.visible?.(viewport) ?? true);
+}
+function andorraClampSize(size, entry) {
+    const min = Math.max(0, Math.floor(entry.minSize ?? 0));
+    const max = Math.max(min, Math.floor(entry.maxSize ?? Number.MAX_SAFE_INTEGER));
+    return Math.max(min, Math.min(max, Math.max(0, Math.floor(size))));
+}
+function andorraDistribute(sizes, entries, amount, mode) {
+    let remaining = amount;
+    while (remaining > 0) {
+        const candidates = entries
+            .map((entry, index) => ({ entry, index }))
+            .filter(({ entry, index }) => {
+            if (mode === "grow") {
+                return (entry.grow ?? 0) > 0 && sizes[index] < (entry.maxSize ?? Number.MAX_SAFE_INTEGER);
+            }
+            return (entry.shrink ?? 1) > 0 && sizes[index] > (entry.minSize ?? 0);
+        });
+        if (candidates.length === 0)
+            return;
+        const totalWeight = candidates.reduce((sum, { entry, index }) => {
+            return sum + (mode === "grow" ? (entry.grow ?? 0) : (entry.shrink ?? 1) * Math.max(1, sizes[index]));
+        }, 0);
+        let distributed = 0;
+        for (const { entry, index } of candidates) {
+            if (remaining <= 0)
+                break;
+            const weight = mode === "grow" ? (entry.grow ?? 0) : (entry.shrink ?? 1) * Math.max(1, sizes[index]);
+            const proposed = Math.max(1, Math.floor((remaining * weight) / totalWeight));
+            const capacity = mode === "grow"
+                ? (entry.maxSize ?? Number.MAX_SAFE_INTEGER) - sizes[index]
+                : sizes[index] - (entry.minSize ?? 0);
+            const delta = Math.min(remaining, proposed, capacity);
+            if (delta <= 0)
+                continue;
+            sizes[index] = sizes[index] + (mode === "grow" ? delta : -delta);
+            remaining -= delta;
+            distributed += delta;
+        }
+        if (distributed === 0)
+            return;
+    }
+}
+export function andorraAllocateStackSizes(entries, intrinsicSizes, availableSize, gap) {
+    const sizes = entries.map((entry, index) => andorraClampSize(entry.basis === undefined || entry.basis === "auto" ? (intrinsicSizes[index] ?? 0) : entry.basis, entry));
+    if (availableSize === undefined)
+        return sizes;
+    const contentSize = Math.max(0, Math.floor(availableSize) - Math.max(0, entries.length - 1) * gap);
+    const total = sizes.reduce((sum, size) => sum + size, 0);
+    if (total < contentSize)
+        andorraDistribute(sizes, entries, contentSize - total, "grow");
+    else if (total > contentSize)
+        andorraDistribute(sizes, entries, total - contentSize, "shrink");
+    return sizes;
+}

package/dist/vendor/engine/runtime/tui/components/text.d.ts

@@ -0,0 +1,18 @@
+import type { Component } from "../tui.js";
+/**
+ * Text component - displays multi-line text with word wrapping
+ */
+export declare class AndorraText implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    private customBgFn?;
+    private cachedText?;
+    private cachedWidth?;
+    private cachedLines?;
+    constructor(text?: string, paddingX?: number, paddingY?: number, customBgFn?: (text: string) => string);
+    setText(text: string): void;
+    setCustomBgFn(customBgFn?: (text: string) => string): void;
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/vendor/engine/runtime/tui/components/text.js

@@ -0,0 +1,89 @@
+import { andorraApplyBackgroundToLine, andorraVisibleWidth, andorraWrapTextWithAnsi } from "../utils.js";
+/**
+ * Text component - displays multi-line text with word wrapping
+ */
+export class AndorraText {
+    text;
+    paddingX; // Left/right padding
+    paddingY; // Top/bottom padding
+    customBgFn;
+    // Cache for rendered output
+    cachedText;
+    cachedWidth;
+    cachedLines;
+    constructor(text = "", paddingX = 1, paddingY = 1, customBgFn) {
+        this.text = text;
+        this.paddingX = paddingX;
+        this.paddingY = paddingY;
+        this.customBgFn = customBgFn;
+    }
+    setText(text) {
+        this.text = text;
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    setCustomBgFn(customBgFn) {
+        this.customBgFn = customBgFn;
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    invalidate() {
+        this.cachedText = undefined;
+        this.cachedWidth = undefined;
+        this.cachedLines = undefined;
+    }
+    render(width) {
+        // Check cache
+        if (this.cachedLines && this.cachedText === this.text && this.cachedWidth === width) {
+            return this.cachedLines;
+        }
+        // Don't render anything if there's no actual text
+        if (!this.text || this.text.trim() === "") {
+            const result = [];
+            this.cachedText = this.text;
+            this.cachedWidth = width;
+            this.cachedLines = result;
+            return result;
+        }
+        // Replace tabs with 3 spaces
+        const normalizedText = this.text.replace(/\t/g, "   ");
+        // Reduce margins when necessary so content and padding fit within the available width.
+        const paddingX = Math.min(this.paddingX, Math.max(0, Math.floor((width - 1) / 2)));
+        const contentWidth = Math.max(1, width - paddingX * 2);
+        // Wrap text (this preserves ANSI codes but does NOT pad)
+        const wrappedLines = andorraWrapTextWithAnsi(normalizedText, contentWidth);
+        // Add margins and background to each line
+        const leftMargin = " ".repeat(paddingX);
+        const rightMargin = " ".repeat(paddingX);
+        const contentLines = [];
+        for (const line of wrappedLines) {
+            // Add margins
+            const lineWithMargins = leftMargin + line + rightMargin;
+            // Apply background if specified (this also pads to full width)
+            if (this.customBgFn) {
+                contentLines.push(andorraApplyBackgroundToLine(lineWithMargins, width, this.customBgFn));
+            }
+            else {
+                // No background - just pad to width with spaces
+                const visibleLen = andorraVisibleWidth(lineWithMargins);
+                const paddingNeeded = Math.max(0, width - visibleLen);
+                contentLines.push(lineWithMargins + " ".repeat(paddingNeeded));
+            }
+        }
+        // Add top/bottom padding (empty lines)
+        const emptyLine = " ".repeat(width);
+        const emptyLines = [];
+        for (let i = 0; i < this.paddingY; i++) {
+            const line = this.customBgFn ? andorraApplyBackgroundToLine(emptyLine, width, this.customBgFn) : emptyLine;
+            emptyLines.push(line);
+        }
+        const result = [...emptyLines, ...contentLines, ...emptyLines];
+        // Update cache
+        this.cachedText = this.text;
+        this.cachedWidth = width;
+        this.cachedLines = result;
+        return result.length > 0 ? result : [""];
+    }
+}

package/dist/vendor/engine/runtime/tui/components/truncated-text.d.ts

@@ -0,0 +1,12 @@
+import type { Component } from "../tui.js";
+/**
+ * Text component that truncates to fit viewport width
+ */
+export declare class AndorraTruncatedText implements Component {
+    private text;
+    private paddingX;
+    private paddingY;
+    constructor(text: string, paddingX?: number, paddingY?: number);
+    invalidate(): void;
+    render(width: number): string[];
+}

package/dist/vendor/engine/runtime/tui/components/truncated-text.js

@@ -0,0 +1,50 @@
+import { andorraTruncateToWidth, andorraVisibleWidth } from "../utils.js";
+/**
+ * Text component that truncates to fit viewport width
+ */
+export class AndorraTruncatedText {
+    text;
+    paddingX;
+    paddingY;
+    constructor(text, paddingX = 0, paddingY = 0) {
+        this.text = text;
+        this.paddingX = paddingX;
+        this.paddingY = paddingY;
+    }
+    invalidate() {
+        // No cached state to invalidate currently
+    }
+    render(width) {
+        const result = [];
+        // Empty line padded to width
+        const emptyLine = " ".repeat(width);
+        // Add vertical padding above
+        for (let i = 0; i < this.paddingY; i++) {
+            result.push(emptyLine);
+        }
+        // Calculate available width after horizontal padding
+        const availableWidth = Math.max(1, width - this.paddingX * 2);
+        // Take only the first line (stop at newline)
+        let singleLineText = this.text;
+        const newlineIndex = this.text.indexOf("\n");
+        if (newlineIndex !== -1) {
+            singleLineText = this.text.substring(0, newlineIndex);
+        }
+        // Truncate text if needed (accounting for ANSI codes)
+        const displayText = andorraTruncateToWidth(singleLineText, availableWidth);
+        // Add horizontal padding
+        const leftPadding = " ".repeat(this.paddingX);
+        const rightPadding = " ".repeat(this.paddingX);
+        const lineWithPadding = leftPadding + displayText + rightPadding;
+        // Pad line to exactly width characters
+        const lineVisibleWidth = andorraVisibleWidth(lineWithPadding);
+        const paddingNeeded = Math.max(0, width - lineVisibleWidth);
+        const finalLine = lineWithPadding + " ".repeat(paddingNeeded);
+        result.push(finalLine);
+        // Add vertical padding below
+        for (let i = 0; i < this.paddingY; i++) {
+            result.push(emptyLine);
+        }
+        return result;
+    }
+}

package/dist/vendor/engine/runtime/tui/components/v-stack.d.ts

@@ -0,0 +1,7 @@
+import { AndorraStack, type StackChild, type StackOptions } from "./stack.js";
+export declare class AndorraVStack extends AndorraStack {
+    protected readonly layoutType: "vstack";
+    constructor(children?: StackChild[], options?: StackOptions);
+    render(width: number): string[];
+}
+export type { StackChild, StackEntry, StackEntryOptions, StackOptions } from "./stack.js";

package/dist/vendor/engine/runtime/tui/components/v-stack.js

@@ -0,0 +1,25 @@
+import { andorraAllocateStackSizes, AndorraStack, andorraVisibleStackEntries } from "./stack.js";
+export class AndorraVStack extends AndorraStack {
+    layoutType = "vstack";
+    constructor(children = [], options = {}) {
+        super(children, options);
+    }
+    render(width) {
+        const viewport = { width: Math.max(1, width), height: Number.MAX_SAFE_INTEGER };
+        const entries = andorraVisibleStackEntries(this.entries, viewport);
+        const rendered = entries.map((entry) => entry.component.render(viewport.width));
+        const sizes = andorraAllocateStackSizes(entries, rendered.map((lines) => lines.length), undefined, this.gap);
+        const lines = [];
+        for (let index = 0; index < entries.length; index++) {
+            if (index > 0) {
+                for (let gap = 0; gap < this.gap; gap++)
+                    lines.push("");
+            }
+            const childLines = rendered[index].slice(0, sizes[index]);
+            lines.push(...childLines);
+            for (let padding = childLines.length; padding < sizes[index]; padding++)
+                lines.push("");
+        }
+        return lines;
+    }
+}

package/dist/vendor/engine/runtime/tui/editor-component.d.ts

@@ -0,0 +1,38 @@
+import type { AutocompleteProvider } from "./autocomplete.js";
+import type { Component } from "./tui.js";
+/**
+ * Interface for custom editor components.
+ *
+ * This allows extensions to provide their own editor implementation
+ * (e.g., vim mode, emacs mode, custom keybindings) while maintaining
+ * compatibility with the core application.
+ */
+export interface EditorComponent extends Component {
+    /** Get the current text content */
+    getText(): string;
+    /** Set the text content */
+    setText(text: string): void;
+    /** Handle raw terminal input (key presses, paste sequences, etc.) */
+    handleInput(data: string): void;
+    /** Called when user submits (e.g., Enter key) */
+    onSubmit?: (text: string) => void;
+    /** Called when text changes */
+    onChange?: (text: string) => void;
+    /** Add text to history for up/down navigation */
+    addToHistory?(text: string): void;
+    /** Insert text at current cursor position */
+    insertTextAtCursor?(text: string): void;
+    /**
+     * Get text with any markers expanded (e.g., paste markers).
+     * Falls back to getText() if not implemented.
+     */
+    getExpandedText?(): string;
+    /** Set the autocomplete provider */
+    setAutocompleteProvider?(provider: AutocompleteProvider): void;
+    /** Border color function */
+    borderColor?: (str: string) => string;
+    /** Set horizontal padding */
+    setPaddingX?(padding: number): void;
+    /** Set max visible items in autocomplete dropdown */
+    setAutocompleteMaxVisible?(maxVisible: number): void;
+}

package/dist/vendor/engine/runtime/tui/editor-component.js

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