@opentui/core 0.0.0-20250908-4906ddad

package/lib/yoga.options.d.ts

@@ -0,0 +1,31 @@
+import { BoxSizing, Align, Dimension, Direction, Display, Edge, FlexDirection, Gutter, Justify, LogLevel, MeasureMode, Overflow, PositionType, Unit, Wrap } from "yoga-layout";
+export type AlignString = "auto" | "flex-start" | "center" | "flex-end" | "stretch" | "baseline" | "space-between" | "space-around" | "space-evenly";
+export type BoxSizingString = "border-box" | "content-box";
+export type DimensionString = "width" | "height";
+export type DirectionString = "inherit" | "ltr" | "rtl";
+export type DisplayString = "flex" | "none" | "contents";
+export type EdgeString = "left" | "top" | "right" | "bottom" | "start" | "end" | "horizontal" | "vertical" | "all";
+export type FlexDirectionString = "column" | "column-reverse" | "row" | "row-reverse";
+export type GutterString = "column" | "row" | "all";
+export type JustifyString = "flex-start" | "center" | "flex-end" | "space-between" | "space-around" | "space-evenly";
+export type LogLevelString = "error" | "warn" | "info" | "debug" | "verbose" | "fatal";
+export type MeasureModeString = "undefined" | "exactly" | "at-most";
+export type OverflowString = "visible" | "hidden" | "scroll";
+export type PositionTypeString = "static" | "relative" | "absolute";
+export type UnitString = "undefined" | "point" | "percent" | "auto";
+export type WrapString = "no-wrap" | "wrap" | "wrap-reverse";
+export declare function parseAlign(value: string): Align;
+export declare function parseBoxSizing(value: string): BoxSizing;
+export declare function parseDimension(value: string): Dimension;
+export declare function parseDirection(value: string): Direction;
+export declare function parseDisplay(value: string): Display;
+export declare function parseEdge(value: string): Edge;
+export declare function parseFlexDirection(value: string): FlexDirection;
+export declare function parseGutter(value: string): Gutter;
+export declare function parseJustify(value: string): Justify;
+export declare function parseLogLevel(value: string): LogLevel;
+export declare function parseMeasureMode(value: string): MeasureMode;
+export declare function parseOverflow(value: string): Overflow;
+export declare function parsePositionType(value: string): PositionType;
+export declare function parseUnit(value: string): Unit;
+export declare function parseWrap(value: string): Wrap;

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@opentui/core",
+  "module": "index.js",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "type": "module",
+  "version": "0.0.0-20250908-4906ddad",
+  "description": "OpenTUI is a TypeScript library for building terminal user interfaces (TUIs)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sst/opentui",
+    "directory": "packages/core"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./3d": {
+      "import": "./3d.js",
+      "require": "./3d.js",
+      "types": "./3d.d.ts"
+    }
+  },
+  "dependencies": {
+    "jimp": "1.6.0",
+    "yoga-layout": "3.2.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/three": "0.177.0",
+    "commander": "^13.1.0"
+  },
+  "optionalDependencies": {
+    "@dimforge/rapier2d-simd-compat": "^0.17.3",
+    "bun-webgpu": "0.1.3",
+    "planck": "^1.4.2",
+    "three": "0.177.0",
+    "@opentui/core-darwin-x64": "0.0.0-20250908-4906ddad",
+    "@opentui/core-darwin-arm64": "0.0.0-20250908-4906ddad",
+    "@opentui/core-linux-x64": "0.0.0-20250908-4906ddad",
+    "@opentui/core-linux-arm64": "0.0.0-20250908-4906ddad",
+    "@opentui/core-win32-x64": "0.0.0-20250908-4906ddad",
+    "@opentui/core-win32-arm64": "0.0.0-20250908-4906ddad"
+  }
+}

package/post/filters.d.ts

@@ -0,0 +1,105 @@
+import type { OptimizedBuffer } from "../buffer";
+/**
+ * Applies a scanline effect by darkening every nth row.
+ */
+export declare function applyScanlines(buffer: OptimizedBuffer, strength?: number, step?: number): void;
+/**
+ * Converts the buffer colors to grayscale.
+ */
+export declare function applyGrayscale(buffer: OptimizedBuffer): void;
+/**
+ * Applies a sepia tone to the buffer.
+ */
+export declare function applySepia(buffer: OptimizedBuffer): void;
+/**
+ * Inverts the colors in the buffer.
+ */
+export declare function applyInvert(buffer: OptimizedBuffer): void;
+/**
+ * Adds random noise to the buffer colors.
+ */
+export declare function applyNoise(buffer: OptimizedBuffer, strength?: number): void;
+/**
+ * Applies a simplified chromatic aberration effect.
+ */
+export declare function applyChromaticAberration(buffer: OptimizedBuffer, strength?: number): void;
+/**
+ * Converts the buffer to ASCII art based on background brightness.
+ */
+export declare function applyAsciiArt(buffer: OptimizedBuffer, ramp?: string): void;
+export declare class DistortionEffect {
+    glitchChancePerSecond: number;
+    maxGlitchLines: number;
+    minGlitchDuration: number;
+    maxGlitchDuration: number;
+    maxShiftAmount: number;
+    shiftFlipRatio: number;
+    colorGlitchChance: number;
+    private lastGlitchTime;
+    private glitchDuration;
+    private activeGlitches;
+    constructor(options?: Partial<DistortionEffect>);
+    /**
+     * Applies the animated distortion/glitch effect to the buffer.
+     */
+    apply(buffer: OptimizedBuffer, deltaTime: number): void;
+}
+/**
+ * Applies a vignette effect by darkening the corners, optimized with precomputation.
+ */
+export declare class VignetteEffect {
+    private _strength;
+    private precomputedBaseAttenuation;
+    private cachedWidth;
+    private cachedHeight;
+    constructor(strength?: number);
+    set strength(newStrength: number);
+    get strength(): number;
+    private _computeFactors;
+    /**
+     * Applies the vignette effect using precomputed base attenuation and current strength.
+     */
+    apply(buffer: OptimizedBuffer): void;
+}
+/**
+ * Adjusts the overall brightness of the buffer.
+ */
+export declare class BrightnessEffect {
+    private _brightness;
+    constructor(brightness?: number);
+    set brightness(newBrightness: number);
+    get brightness(): number;
+    /**
+     * Applies the brightness adjustment to the buffer.
+     */
+    apply(buffer: OptimizedBuffer): void;
+}
+/**
+ * Applies a simple box blur. (Expensive and may look bad with text).
+ */
+export declare class BlurEffect {
+    private _radius;
+    constructor(radius?: number);
+    set radius(newRadius: number);
+    get radius(): number;
+    /**
+     * Applies an optimized separable box blur using a moving average (sliding window).
+     */
+    apply(buffer: OptimizedBuffer): void;
+}
+/**
+ * Applies a bloom effect based on bright areas (Simplified).
+ */
+export declare class BloomEffect {
+    private _threshold;
+    private _strength;
+    private _radius;
+    constructor(threshold?: number, strength?: number, radius?: number);
+    set threshold(newThreshold: number);
+    get threshold(): number;
+    set strength(newStrength: number);
+    get strength(): number;
+    set radius(newRadius: number);
+    get radius(): number;
+    apply(buffer: OptimizedBuffer): void;
+}

package/renderables/ASCIIFont.d.ts

@@ -0,0 +1,43 @@
+import type { RenderableOptions } from "../Renderable";
+import { Selection } from "../lib/selection";
+import { type fonts, type ASCIIFontName } from "../lib/ascii.font";
+import { RGBA } from "../lib/RGBA";
+import { FrameBufferRenderable } from "./FrameBuffer";
+import type { RenderContext } from "../types";
+export interface ASCIIFontOptions extends RenderableOptions<ASCIIFontRenderable> {
+    text?: string;
+    font?: ASCIIFontName;
+    fg?: RGBA | RGBA[];
+    bg?: RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+}
+export declare class ASCIIFontRenderable extends FrameBufferRenderable {
+    selectable: boolean;
+    private _text;
+    private _font;
+    private _fg;
+    private _bg;
+    private _selectionBg;
+    private _selectionFg;
+    private lastLocalSelection;
+    private selectionHelper;
+    constructor(ctx: RenderContext, options: ASCIIFontOptions);
+    get text(): string;
+    set text(value: string);
+    get font(): keyof typeof fonts;
+    set font(value: keyof typeof fonts);
+    get fg(): RGBA[];
+    set fg(value: RGBA | RGBA[] | string | string[]);
+    get bg(): RGBA;
+    set bg(value: RGBA | string);
+    private updateDimensions;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    protected onResize(width: number, height: number): void;
+    private renderFontToBuffer;
+    private renderSelectionHighlight;
+}

package/renderables/Box.d.ts

@@ -0,0 +1,70 @@
+import { type RenderableOptions, Renderable } from "../Renderable";
+import type { OptimizedBuffer } from "../buffer";
+import { type BorderCharacters, type BorderSides, type BorderSidesConfig, type BorderStyle } from "../lib";
+import { type ColorInput, RGBA } from "../lib/RGBA";
+import type { RenderContext } from "../types";
+export interface BoxOptions<TRenderable extends Renderable = BoxRenderable> extends RenderableOptions<TRenderable> {
+    backgroundColor?: string | RGBA;
+    borderStyle?: BorderStyle;
+    border?: boolean | BorderSides[];
+    borderColor?: string | RGBA;
+    customBorderChars?: BorderCharacters;
+    shouldFill?: boolean;
+    title?: string;
+    titleAlignment?: "left" | "center" | "right";
+    focusedBorderColor?: ColorInput;
+    gap?: number | `${number}%`;
+    rowGap?: number | `${number}%`;
+    columnGap?: number | `${number}%`;
+}
+export declare class BoxRenderable extends Renderable {
+    protected _backgroundColor: RGBA;
+    protected _border: boolean | BorderSides[];
+    protected _borderStyle: BorderStyle;
+    protected _borderColor: RGBA;
+    protected _focusedBorderColor: RGBA;
+    private _customBorderCharsObj;
+    protected _customBorderChars?: Uint32Array;
+    protected borderSides: BorderSidesConfig;
+    shouldFill: boolean;
+    protected _title?: string;
+    protected _titleAlignment: "left" | "center" | "right";
+    protected _defaultOptions: {
+        backgroundColor: string;
+        borderStyle: "single";
+        border: false;
+        borderColor: string;
+        shouldFill: true;
+        titleAlignment: "left";
+        focusedBorderColor: string;
+    };
+    constructor(ctx: RenderContext, options: BoxOptions);
+    get customBorderChars(): BorderCharacters | undefined;
+    set customBorderChars(value: BorderCharacters | undefined);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: RGBA | string | undefined);
+    get border(): boolean | BorderSides[];
+    set border(value: boolean | BorderSides[]);
+    get borderStyle(): BorderStyle;
+    set borderStyle(value: BorderStyle);
+    get borderColor(): RGBA;
+    set borderColor(value: RGBA | string);
+    get focusedBorderColor(): RGBA;
+    set focusedBorderColor(value: RGBA | string);
+    get title(): string | undefined;
+    set title(value: string | undefined);
+    get titleAlignment(): "left" | "center" | "right";
+    set titleAlignment(value: "left" | "center" | "right");
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected getScissorRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    private applyYogaBorders;
+    private applyYogaGap;
+    set gap(gap: number | `${number}%` | undefined);
+    set rowGap(rowGap: number | `${number}%` | undefined);
+    set columnGap(columnGap: number | `${number}%` | undefined);
+}

package/renderables/FrameBuffer.d.ts

@@ -0,0 +1,16 @@
+import { type RenderableOptions, Renderable } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+import type { RenderContext } from "../types";
+export interface FrameBufferOptions extends RenderableOptions<FrameBufferRenderable> {
+    width: number;
+    height: number;
+    respectAlpha?: boolean;
+}
+export declare class FrameBufferRenderable extends Renderable {
+    frameBuffer: OptimizedBuffer;
+    protected respectAlpha: boolean;
+    constructor(ctx: RenderContext, options: FrameBufferOptions);
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected destroySelf(): void;
+}

package/renderables/Input.d.ts

@@ -0,0 +1,70 @@
+import { OptimizedBuffer } from "../buffer";
+import type { ParsedKey } from "../lib/parse.keypress";
+import { type ColorInput } from "../lib/RGBA";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+export interface InputRenderableOptions extends RenderableOptions<InputRenderable> {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    placeholder?: string;
+    placeholderColor?: ColorInput;
+    cursorColor?: ColorInput;
+    maxLength?: number;
+    value?: string;
+}
+export declare enum InputRenderableEvents {
+    INPUT = "input",
+    CHANGE = "change",
+    ENTER = "enter"
+}
+export declare class InputRenderable extends Renderable {
+    protected focusable: boolean;
+    private _value;
+    private _cursorPosition;
+    private _placeholder;
+    private _backgroundColor;
+    private _textColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _placeholderColor;
+    private _cursorColor;
+    private _maxLength;
+    private _lastCommittedValue;
+    protected _defaultOptions: {
+        backgroundColor: string;
+        textColor: string;
+        focusedBackgroundColor: string;
+        focusedTextColor: string;
+        placeholder: string;
+        placeholderColor: string;
+        cursorColor: string;
+        maxLength: number;
+        value: string;
+    };
+    constructor(ctx: RenderContext, options: InputRenderableOptions);
+    private updateCursorPosition;
+    focus(): void;
+    blur(): void;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    get value(): string;
+    set value(value: string);
+    set placeholder(placeholder: string);
+    get cursorPosition(): number;
+    set cursorPosition(position: number);
+    private insertText;
+    private deleteCharacter;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    set maxLength(maxLength: number);
+    set backgroundColor(value: ColorInput);
+    set textColor(value: ColorInput);
+    set focusedBackgroundColor(value: ColorInput);
+    set focusedTextColor(value: ColorInput);
+    set placeholderColor(value: ColorInput);
+    set cursorColor(value: ColorInput);
+    updateFromLayout(): void;
+    protected onResize(width: number, height: number): void;
+    protected onRemove(): void;
+}

package/renderables/ScrollBar.d.ts

@@ -0,0 +1,77 @@
+import type { OptimizedBuffer } from "../buffer";
+import { RGBA, type ColorInput } from "../lib";
+import type { ParsedKey } from "../lib/parse.keypress";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+import { SliderRenderable, type SliderOptions } from "./Slider";
+export interface ScrollBarOptions extends RenderableOptions<ScrollBarRenderable> {
+    orientation: "vertical" | "horizontal";
+    showArrows?: boolean;
+    arrowOptions?: Omit<ArrowOptions, "direction">;
+    trackOptions?: Partial<SliderOptions>;
+    onChange?: (position: number) => void;
+}
+export type ScrollUnit = "absolute" | "viewport" | "content" | "step";
+export declare class ScrollBarRenderable extends Renderable {
+    readonly slider: SliderRenderable;
+    readonly startArrow: ArrowRenderable;
+    readonly endArrow: ArrowRenderable;
+    readonly orientation: "vertical" | "horizontal";
+    protected focusable: boolean;
+    private _scrollSize;
+    private _scrollPosition;
+    private _viewportSize;
+    private _showArrows;
+    private _manualVisibility;
+    private _onChange;
+    scrollStep: number | undefined | null;
+    get visible(): boolean;
+    set visible(value: boolean);
+    resetVisibilityControl(): void;
+    get scrollSize(): number;
+    get scrollPosition(): number;
+    get viewportSize(): number;
+    set scrollSize(value: number);
+    set scrollPosition(value: number);
+    set viewportSize(value: number);
+    get showArrows(): boolean;
+    set showArrows(value: boolean);
+    constructor(ctx: RenderContext, { trackOptions, arrowOptions, orientation, showArrows, ...options }: ScrollBarOptions);
+    set arrowOptions(options: ScrollBarOptions["arrowOptions"]);
+    set trackOptions(options: ScrollBarOptions["trackOptions"]);
+    private updateSliderFromScrollState;
+    scrollBy(delta: number, unit?: ScrollUnit): void;
+    private recalculateVisibility;
+    handleKeyPress(key: ParsedKey | string): boolean;
+}
+export interface ArrowOptions extends RenderableOptions<ArrowRenderable> {
+    direction: "up" | "down" | "left" | "right";
+    foregroundColor?: ColorInput;
+    backgroundColor?: ColorInput;
+    attributes?: number;
+    arrowChars?: {
+        up?: string;
+        down?: string;
+        left?: string;
+        right?: string;
+    };
+}
+export declare class ArrowRenderable extends Renderable {
+    private _direction;
+    private _foregroundColor;
+    private _backgroundColor;
+    private _attributes;
+    private _arrowChars;
+    constructor(ctx: RenderContext, options: ArrowOptions);
+    get direction(): "up" | "down" | "left" | "right";
+    set direction(value: "up" | "down" | "left" | "right");
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get attributes(): number;
+    set attributes(value: number);
+    set arrowChars(value: ArrowOptions["arrowChars"]);
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private getArrowChar;
+}

package/renderables/ScrollBox.d.ts

@@ -0,0 +1,82 @@
+import { type ParsedKey } from "../lib";
+import type { Renderable, RenderableOptions } from "../Renderable";
+import type { MouseEvent } from "../renderer";
+import type { RenderContext } from "../types";
+import { BoxRenderable, type BoxOptions } from "./Box";
+import type { VNode } from "./composition/vnode";
+import { ScrollBarRenderable, type ScrollBarOptions, type ScrollUnit } from "./ScrollBar";
+declare class ContentRenderable extends BoxRenderable {
+    private viewport;
+    constructor(ctx: RenderContext, viewport: BoxRenderable, options: RenderableOptions<BoxRenderable>);
+    protected _getChildren(): Renderable[];
+}
+export interface ScrollBoxOptions extends BoxOptions<ScrollBoxRenderable> {
+    rootOptions?: BoxOptions;
+    wrapperOptions?: BoxOptions;
+    viewportOptions?: BoxOptions;
+    contentOptions?: BoxOptions;
+    scrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    verticalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+    horizontalScrollbarOptions?: Omit<ScrollBarOptions, "orientation">;
+}
+export declare class ScrollBoxRenderable extends BoxRenderable {
+    static idCounter: number;
+    private internalId;
+    readonly wrapper: BoxRenderable;
+    readonly viewport: BoxRenderable;
+    readonly content: ContentRenderable;
+    readonly horizontalScrollBar: ScrollBarRenderable;
+    readonly verticalScrollBar: ScrollBarRenderable;
+    protected focusable: boolean;
+    private selectionListener?;
+    private autoScrollMouseX;
+    private autoScrollMouseY;
+    private readonly autoScrollThresholdVertical;
+    private readonly autoScrollThresholdHorizontal;
+    private readonly autoScrollSpeedSlow;
+    private readonly autoScrollSpeedMedium;
+    private readonly autoScrollSpeedFast;
+    private isAutoScrolling;
+    private cachedAutoScrollSpeed;
+    private autoScrollAccumulatorX;
+    private autoScrollAccumulatorY;
+    get scrollTop(): number;
+    set scrollTop(value: number);
+    get scrollLeft(): number;
+    set scrollLeft(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    constructor(ctx: RenderContext, { wrapperOptions, viewportOptions, contentOptions, rootOptions, scrollbarOptions, verticalScrollbarOptions, horizontalScrollbarOptions, ...options }: ScrollBoxOptions);
+    protected onUpdate(deltaTime: number): void;
+    scrollBy(delta: number | {
+        x: number;
+        y: number;
+    }, unit?: ScrollUnit): void;
+    scrollTo(position: number | {
+        x: number;
+        y: number;
+    }): void;
+    add(obj: Renderable | VNode<any, any[]>, index?: number): number;
+    remove(id: string): void;
+    getChildren(): Renderable[];
+    protected onMouseEvent(event: MouseEvent): void;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    startAutoScroll(mouseX: number, mouseY: number): void;
+    updateAutoScroll(mouseX: number, mouseY: number): void;
+    stopAutoScroll(): void;
+    private hasOtherLiveReasons;
+    private handleAutoScroll;
+    private getAutoScrollDirectionX;
+    private getAutoScrollDirectionY;
+    private getAutoScrollSpeed;
+    private recalculateBarProps;
+    set rootOptions(options: ScrollBoxOptions["rootOptions"]);
+    set wrapperOptions(options: ScrollBoxOptions["wrapperOptions"]);
+    set viewportOptions(options: ScrollBoxOptions["viewportOptions"]);
+    set contentOptions(options: ScrollBoxOptions["contentOptions"]);
+    set scrollbarOptions(options: ScrollBoxOptions["scrollbarOptions"]);
+    set verticalScrollbarOptions(options: ScrollBoxOptions["verticalScrollbarOptions"]);
+    set horizontalScrollbarOptions(options: ScrollBoxOptions["horizontalScrollbarOptions"]);
+    protected destroySelf(): void;
+}
+export {};

package/renderables/Select.d.ts

@@ -0,0 +1,102 @@
+import { OptimizedBuffer } from "../buffer";
+import { fonts } from "../lib/ascii.font";
+import type { ParsedKey } from "../lib/parse.keypress";
+import { type ColorInput } from "../lib/RGBA";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+export interface SelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export interface SelectRenderableOptions extends RenderableOptions<SelectRenderable> {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    options?: SelectOption[];
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    descriptionColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollIndicator?: boolean;
+    wrapSelection?: boolean;
+    showDescription?: boolean;
+    font?: keyof typeof fonts;
+    itemSpacing?: number;
+    fastScrollStep?: number;
+}
+export declare enum SelectRenderableEvents {
+    SELECTION_CHANGED = "selectionChanged",
+    ITEM_SELECTED = "itemSelected"
+}
+export declare class SelectRenderable extends Renderable {
+    protected focusable: boolean;
+    private _options;
+    private selectedIndex;
+    private scrollOffset;
+    private maxVisibleItems;
+    private _backgroundColor;
+    private _textColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _selectedBackgroundColor;
+    private _selectedTextColor;
+    private _descriptionColor;
+    private _selectedDescriptionColor;
+    private _showScrollIndicator;
+    private _wrapSelection;
+    private _showDescription;
+    private _font?;
+    private _itemSpacing;
+    private linesPerItem;
+    private fontHeight;
+    private _fastScrollStep;
+    protected _defaultOptions: {
+        backgroundColor: string;
+        textColor: string;
+        focusedBackgroundColor: string;
+        focusedTextColor: string;
+        selectedBackgroundColor: string;
+        selectedTextColor: string;
+        descriptionColor: string;
+        selectedDescriptionColor: string;
+        showScrollIndicator: false;
+        wrapSelection: false;
+        showDescription: true;
+        itemSpacing: number;
+        fastScrollStep: number;
+    };
+    constructor(ctx: RenderContext, options: SelectRenderableOptions);
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private renderScrollIndicatorToFrameBuffer;
+    get options(): SelectOption[];
+    set options(options: SelectOption[]);
+    getSelectedOption(): SelectOption | null;
+    getSelectedIndex(): number;
+    moveUp(steps?: number): void;
+    moveDown(steps?: number): void;
+    selectCurrent(): void;
+    setSelectedIndex(index: number): void;
+    private updateScrollOffset;
+    protected onResize(width: number, height: number): void;
+    handleKeyPress(key: ParsedKey | string): boolean;
+    get showScrollIndicator(): boolean;
+    set showScrollIndicator(show: boolean);
+    get showDescription(): boolean;
+    set showDescription(show: boolean);
+    get wrapSelection(): boolean;
+    set wrapSelection(wrap: boolean);
+    set backgroundColor(value: ColorInput);
+    set textColor(value: ColorInput);
+    set focusedBackgroundColor(value: ColorInput);
+    set focusedTextColor(value: ColorInput);
+    set selectedBackgroundColor(value: ColorInput);
+    set selectedTextColor(value: ColorInput);
+    set descriptionColor(value: ColorInput);
+    set selectedDescriptionColor(value: ColorInput);
+    set font(font: keyof typeof fonts);
+    set itemSpacing(spacing: number);
+    set fastScrollStep(step: number);
+}

package/renderables/Slider.d.ts

@@ -0,0 +1,31 @@
+import { type ColorInput, OptimizedBuffer, Renderable, type RenderableOptions, type RenderContext, RGBA } from "../index";
+export interface SliderOptions extends RenderableOptions<SliderRenderable> {
+    orientation: "vertical" | "horizontal";
+    thumbSize?: number;
+    thumbPosition?: number;
+    backgroundColor?: ColorInput;
+    foregroundColor?: ColorInput;
+    onChange?: (position: number) => void;
+}
+export declare class SliderRenderable extends Renderable {
+    readonly orientation: "vertical" | "horizontal";
+    private _thumbSize;
+    private _thumbPosition;
+    private _backgroundColor;
+    private _foregroundColor;
+    private _onChange?;
+    constructor(ctx: RenderContext, options: SliderOptions);
+    get thumbSize(): number;
+    set thumbSize(value: number);
+    get thumbPosition(): number;
+    set thumbPosition(value: number);
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    private setupMouseHandling;
+    private updatePositionFromMouse;
+    private getThumbPosition;
+    private getThumbRect;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+}