@cascadetui/core 0.1.1

package/renderables/Select.d.ts

@@ -0,0 +1,115 @@
+import { OptimizedBuffer } from "../buffer";
+import { fonts } from "../lib/ascii.font";
+import type { KeyEvent } from "../lib/KeyHandler";
+import { type ColorInput } from "../lib/RGBA";
+import { Renderable, type RenderableOptions } from "../Renderable";
+import type { RenderContext } from "../types";
+import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping";
+export interface SelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export type SelectAction = "move-up" | "move-down" | "move-up-fast" | "move-down-fast" | "select-current";
+export type SelectKeyBinding = BaseKeyBinding<SelectAction>;
+export interface SelectRenderableOptions extends RenderableOptions<SelectRenderable> {
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    options?: SelectOption[];
+    selectedIndex?: number;
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    descriptionColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollIndicator?: boolean;
+    wrapSelection?: boolean;
+    showDescription?: boolean;
+    font?: keyof typeof fonts;
+    itemSpacing?: number;
+    fastScrollStep?: number;
+    keyBindings?: SelectKeyBinding[];
+    keyAliasMap?: KeyAliasMap;
+}
+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;
+    private _keyBindingsMap;
+    private _keyAliasMap;
+    private _keyBindings;
+    protected _defaultOptions: {
+        backgroundColor: string;
+        textColor: string;
+        focusedBackgroundColor: string;
+        focusedTextColor: string;
+        selectedBackgroundColor: string;
+        selectedTextColor: string;
+        selectedIndex: number;
+        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: KeyEvent): 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);
+    set keyBindings(bindings: SelectKeyBinding[]);
+    set keyAliasMap(aliases: KeyAliasMap);
+    set selectedIndex(value: number);
+}

package/renderables/Slider.d.ts

@@ -0,0 +1,44 @@
+import { type ColorInput, OptimizedBuffer, Renderable, type RenderableOptions, type RenderContext, RGBA } from "../index";
+export interface SliderOptions extends RenderableOptions<SliderRenderable> {
+    orientation: "vertical" | "horizontal";
+    value?: number;
+    min?: number;
+    max?: number;
+    viewPortSize?: number;
+    backgroundColor?: ColorInput;
+    foregroundColor?: ColorInput;
+    onChange?: (value: number) => void;
+}
+export declare class SliderRenderable extends Renderable {
+    readonly orientation: "vertical" | "horizontal";
+    private _value;
+    private _min;
+    private _max;
+    private _viewPortSize;
+    private _backgroundColor;
+    private _foregroundColor;
+    private _onChange?;
+    constructor(ctx: RenderContext, options: SliderOptions);
+    get value(): number;
+    set value(newValue: number);
+    get min(): number;
+    set min(newMin: number);
+    get max(): number;
+    set max(newMax: number);
+    set viewPortSize(size: number);
+    get viewPortSize(): number;
+    get backgroundColor(): RGBA;
+    set backgroundColor(value: ColorInput);
+    get foregroundColor(): RGBA;
+    set foregroundColor(value: ColorInput);
+    private calculateDragOffsetVirtual;
+    private setupMouseHandling;
+    private updateValueFromMouseDirect;
+    private updateValueFromMouseWithOffset;
+    private getThumbRect;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    private renderHorizontal;
+    private renderVertical;
+    private getVirtualThumbSize;
+    private getVirtualThumbStart;
+}

package/renderables/TabSelect.d.ts

@@ -0,0 +1,96 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { OptimizedBuffer } from "../buffer";
+import { type ColorInput } from "../lib/RGBA";
+import type { KeyEvent } from "../lib/KeyHandler";
+import type { RenderContext } from "../types";
+import { type KeyBinding as BaseKeyBinding, type KeyAliasMap } from "../lib/keymapping";
+export interface TabSelectOption {
+    name: string;
+    description: string;
+    value?: any;
+}
+export type TabSelectAction = "move-left" | "move-right" | "select-current";
+export type TabSelectKeyBinding = BaseKeyBinding<TabSelectAction>;
+export interface TabSelectRenderableOptions extends Omit<RenderableOptions<TabSelectRenderable>, "height"> {
+    height?: number;
+    options?: TabSelectOption[];
+    tabWidth?: number;
+    backgroundColor?: ColorInput;
+    textColor?: ColorInput;
+    focusedBackgroundColor?: ColorInput;
+    focusedTextColor?: ColorInput;
+    selectedBackgroundColor?: ColorInput;
+    selectedTextColor?: ColorInput;
+    selectedDescriptionColor?: ColorInput;
+    showScrollArrows?: boolean;
+    showDescription?: boolean;
+    showUnderline?: boolean;
+    wrapSelection?: boolean;
+    keyBindings?: TabSelectKeyBinding[];
+    keyAliasMap?: KeyAliasMap;
+}
+export declare enum TabSelectRenderableEvents {
+    SELECTION_CHANGED = "selectionChanged",
+    ITEM_SELECTED = "itemSelected"
+}
+export declare class TabSelectRenderable extends Renderable {
+    protected _focusable: boolean;
+    private _options;
+    private selectedIndex;
+    private scrollOffset;
+    private _tabWidth;
+    private maxVisibleTabs;
+    private _backgroundColor;
+    private _textColor;
+    private _focusedBackgroundColor;
+    private _focusedTextColor;
+    private _selectedBackgroundColor;
+    private _selectedTextColor;
+    private _selectedDescriptionColor;
+    private _showScrollArrows;
+    private _showDescription;
+    private _showUnderline;
+    private _wrapSelection;
+    private _keyBindingsMap;
+    private _keyAliasMap;
+    private _keyBindings;
+    constructor(ctx: RenderContext, options: TabSelectRenderableOptions);
+    private calculateDynamicHeight;
+    protected renderSelf(buffer: OptimizedBuffer, deltaTime: number): void;
+    private refreshFrameBuffer;
+    private truncateText;
+    private renderScrollArrowsToFrameBuffer;
+    setOptions(options: TabSelectOption[]): void;
+    getSelectedOption(): TabSelectOption | null;
+    getSelectedIndex(): number;
+    moveLeft(): void;
+    moveRight(): void;
+    selectCurrent(): void;
+    setSelectedIndex(index: number): void;
+    private updateScrollOffset;
+    protected onResize(width: number, height: number): void;
+    setTabWidth(tabWidth: number): void;
+    getTabWidth(): number;
+    handleKeyPress(key: KeyEvent): boolean;
+    get options(): TabSelectOption[];
+    set options(options: TabSelectOption[]);
+    set backgroundColor(color: ColorInput);
+    set textColor(color: ColorInput);
+    set focusedBackgroundColor(color: ColorInput);
+    set focusedTextColor(color: ColorInput);
+    set selectedBackgroundColor(color: ColorInput);
+    set selectedTextColor(color: ColorInput);
+    set selectedDescriptionColor(color: ColorInput);
+    get showDescription(): boolean;
+    set showDescription(show: boolean);
+    get showUnderline(): boolean;
+    set showUnderline(show: boolean);
+    get showScrollArrows(): boolean;
+    set showScrollArrows(show: boolean);
+    get wrapSelection(): boolean;
+    set wrapSelection(wrap: boolean);
+    get tabWidth(): number;
+    set tabWidth(tabWidth: number);
+    set keyBindings(bindings: TabSelectKeyBinding[]);
+    set keyAliasMap(aliases: KeyAliasMap);
+}

package/renderables/Text.d.ts

@@ -0,0 +1,36 @@
+import { BaseRenderable } from "../Renderable";
+import { StyledText } from "../lib/styled-text";
+import { type TextChunk } from "../text-buffer";
+import { RGBA } from "../lib/RGBA";
+import { type RenderContext } from "../types";
+import { RootTextNodeRenderable, TextNodeRenderable } from "./TextNode";
+import { TextBufferRenderable, type TextBufferOptions } from "./TextBufferRenderable";
+export interface TextOptions extends TextBufferOptions {
+    content?: StyledText | string;
+}
+export declare class TextRenderable extends TextBufferRenderable {
+    private _text;
+    private _hasManualStyledText;
+    protected rootTextNode: RootTextNodeRenderable;
+    protected _contentDefaultOptions: {
+        content: string;
+    };
+    constructor(ctx: RenderContext, options: TextOptions);
+    private updateTextBuffer;
+    private clearChunks;
+    get content(): StyledText;
+    get chunks(): TextChunk[];
+    get textNode(): RootTextNodeRenderable;
+    set content(value: StyledText | string);
+    private updateTextFromNodes;
+    add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
+    remove(id: string): void;
+    insertBefore(obj: BaseRenderable | any, anchor?: TextNodeRenderable): number;
+    getTextChildren(): BaseRenderable[];
+    clear(): void;
+    onLifecyclePass: () => void;
+    protected onFgChanged(newColor: RGBA): void;
+    protected onBgChanged(newColor: RGBA): void;
+    protected onAttributesChanged(newAttributes: number): void;
+    destroy(): void;
+}

package/renderables/TextBufferRenderable.d.ts

@@ -0,0 +1,105 @@
+import { Renderable, type RenderableOptions } from "../Renderable";
+import { Selection, type LocalSelectionBounds } from "../lib/selection";
+import { TextBuffer } from "../text-buffer";
+import { TextBufferView } from "../text-buffer-view";
+import { RGBA } from "../lib/RGBA";
+import { type RenderContext, type LineInfoProvider } from "../types";
+import type { OptimizedBuffer } from "../buffer";
+import type { LineInfo } from "../zig";
+import { SyntaxStyle } from "../syntax-style";
+export interface TextBufferOptions extends RenderableOptions<TextBufferRenderable> {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    selectionBg?: string | RGBA;
+    selectionFg?: string | RGBA;
+    selectable?: boolean;
+    attributes?: number;
+    wrapMode?: "none" | "char" | "word";
+    tabIndicator?: string | number;
+    tabIndicatorColor?: string | RGBA;
+    truncate?: boolean;
+}
+export declare abstract class TextBufferRenderable extends Renderable implements LineInfoProvider {
+    selectable: boolean;
+    protected _defaultFg: RGBA;
+    protected _defaultBg: RGBA;
+    protected _defaultAttributes: number;
+    protected _selectionBg: RGBA | undefined;
+    protected _selectionFg: RGBA | undefined;
+    protected _wrapMode: "none" | "char" | "word";
+    protected lastLocalSelection: LocalSelectionBounds | null;
+    protected _tabIndicator?: string | number;
+    protected _tabIndicatorColor?: RGBA;
+    protected _scrollX: number;
+    protected _scrollY: number;
+    protected _truncate: boolean;
+    protected textBuffer: TextBuffer;
+    protected textBufferView: TextBufferView;
+    protected _textBufferSyntaxStyle: SyntaxStyle;
+    protected _defaultOptions: {
+        fg: RGBA;
+        bg: RGBA;
+        selectionBg: undefined;
+        selectionFg: undefined;
+        selectable: true;
+        attributes: number;
+        wrapMode: "none" | "char" | "word";
+        tabIndicator: undefined;
+        tabIndicatorColor: undefined;
+        truncate: false;
+    };
+    constructor(ctx: RenderContext, options: TextBufferOptions);
+    protected onMouseEvent(event: any): void;
+    protected handleScroll(event: any): void;
+    get lineInfo(): LineInfo;
+    get lineCount(): number;
+    get virtualLineCount(): number;
+    get scrollY(): number;
+    set scrollY(value: number);
+    get scrollX(): number;
+    set scrollX(value: number);
+    get scrollWidth(): number;
+    get scrollHeight(): number;
+    get maxScrollY(): number;
+    get maxScrollX(): number;
+    protected updateViewportOffset(): void;
+    get plainText(): string;
+    get textLength(): number;
+    get fg(): RGBA;
+    set fg(value: RGBA | string | undefined);
+    get selectionBg(): RGBA | undefined;
+    set selectionBg(value: RGBA | string | undefined);
+    get selectionFg(): RGBA | undefined;
+    set selectionFg(value: RGBA | string | undefined);
+    get bg(): RGBA;
+    set bg(value: RGBA | string | undefined);
+    get attributes(): number;
+    set attributes(value: number);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get tabIndicator(): string | number | undefined;
+    set tabIndicator(value: string | number | undefined);
+    get tabIndicatorColor(): RGBA | undefined;
+    set tabIndicatorColor(value: RGBA | string | undefined);
+    get truncate(): boolean;
+    set truncate(value: boolean);
+    protected onResize(width: number, height: number): void;
+    protected refreshLocalSelection(): boolean;
+    private updateLocalSelection;
+    protected updateTextInfo(): void;
+    private setupMeasureFunc;
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    getSelectedText(): string;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    render(buffer: OptimizedBuffer, deltaTime: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    destroy(): void;
+    protected onFgChanged(newColor: RGBA): void;
+    protected onBgChanged(newColor: RGBA): void;
+    protected onAttributesChanged(newAttributes: number): void;
+}

package/renderables/TextNode.d.ts

@@ -0,0 +1,91 @@
+import type { TextRenderable } from ".";
+import { BaseRenderable, type BaseRenderableOptions } from "../Renderable";
+import { RGBA } from "../lib/RGBA";
+import { StyledText } from "../lib/styled-text";
+import { type TextChunk } from "../text-buffer";
+import type { RenderContext } from "../types";
+export interface TextNodeOptions extends BaseRenderableOptions {
+    fg?: string | RGBA;
+    bg?: string | RGBA;
+    attributes?: number;
+    link?: {
+        url: string;
+    };
+}
+declare const BrandedTextNodeRenderable: unique symbol;
+export declare function isTextNodeRenderable(obj: any): obj is TextNodeRenderable;
+export declare class TextNodeRenderable extends BaseRenderable {
+    [BrandedTextNodeRenderable]: boolean;
+    private _fg?;
+    private _bg?;
+    private _attributes;
+    private _link?;
+    private _children;
+    parent: TextNodeRenderable | null;
+    constructor(options: TextNodeOptions);
+    get children(): (string | TextNodeRenderable)[];
+    set children(children: (string | TextNodeRenderable)[]);
+    requestRender(): void;
+    add(obj: TextNodeRenderable | StyledText | string, index?: number): number;
+    replace(obj: TextNodeRenderable | string, index: number): void;
+    insertBefore(child: string | TextNodeRenderable | StyledText, anchorNode: TextNodeRenderable | string | unknown): this;
+    remove(id: string): this;
+    clear(): void;
+    mergeStyles(parentStyle: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    }): {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    };
+    gatherWithInheritedStyle(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    }): TextChunk[];
+    static fromString(text: string, options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    static fromNodes(nodes: TextNodeRenderable[], options?: Partial<TextNodeOptions>): TextNodeRenderable;
+    toChunks(parentStyle?: {
+        fg?: RGBA;
+        bg?: RGBA;
+        attributes: number;
+        link?: {
+            url: string;
+        };
+    }): TextChunk[];
+    getChildren(): BaseRenderable[];
+    getChildrenCount(): number;
+    getRenderable(id: string): BaseRenderable | undefined;
+    getRenderableIndex(id: string): number;
+    get fg(): RGBA | undefined;
+    set fg(fg: RGBA | string | undefined);
+    set bg(bg: RGBA | string | undefined);
+    get bg(): RGBA | undefined;
+    set attributes(attributes: number);
+    get attributes(): number;
+    set link(link: {
+        url: string;
+    } | undefined);
+    get link(): {
+        url: string;
+    } | undefined;
+    findDescendantById(id: string): BaseRenderable | undefined;
+}
+export declare class RootTextNodeRenderable extends TextNodeRenderable {
+    private readonly ctx;
+    textParent: TextRenderable;
+    constructor(ctx: RenderContext, options: TextNodeOptions, textParent: TextRenderable);
+    requestRender(): void;
+}
+export {};

package/renderables/TextTable.d.ts

@@ -0,0 +1,130 @@
+import { type RenderableOptions, Renderable } from "../Renderable";
+import type { OptimizedBuffer } from "../buffer";
+import { type BorderStyle } from "../lib/border";
+import { type Selection } from "../lib/selection";
+import { RGBA, type ColorInput } from "../lib/RGBA";
+import { type TextChunk } from "../text-buffer";
+import type { RenderContext } from "../types";
+export type TextTableCellContent = TextChunk[] | null | undefined;
+export type TextTableContent = TextTableCellContent[][];
+export type TextTableColumnWidthMode = "content" | "fill";
+export interface TextTableOptions extends RenderableOptions<TextTableRenderable> {
+    content?: TextTableContent;
+    wrapMode?: "none" | "char" | "word";
+    columnWidthMode?: TextTableColumnWidthMode;
+    cellPadding?: number;
+    showBorders?: boolean;
+    border?: boolean;
+    outerBorder?: boolean;
+    selectable?: boolean;
+    selectionBg?: ColorInput;
+    selectionFg?: ColorInput;
+    borderStyle?: BorderStyle;
+    borderColor?: ColorInput;
+    borderBackgroundColor?: ColorInput;
+    backgroundColor?: ColorInput;
+    fg?: ColorInput;
+    bg?: ColorInput;
+    attributes?: number;
+}
+export declare class TextTableRenderable extends Renderable {
+    private _content;
+    private _wrapMode;
+    private _columnWidthMode;
+    private _cellPadding;
+    private _showBorders;
+    private _border;
+    private _outerBorder;
+    private _hasExplicitOuterBorder;
+    private _borderStyle;
+    private _borderColor;
+    private _borderBackgroundColor;
+    private _backgroundColor;
+    private _defaultFg;
+    private _defaultBg;
+    private _defaultAttributes;
+    private _selectionBg;
+    private _selectionFg;
+    private _lastLocalSelection;
+    private _lastSelectionMode;
+    private _cells;
+    private _prevCellContent;
+    private _rowCount;
+    private _columnCount;
+    private _layout;
+    private _layoutDirty;
+    private _rasterDirty;
+    private _cachedMeasureLayout;
+    private _cachedMeasureWidth;
+    private readonly _defaultOptions;
+    constructor(ctx: RenderContext, options?: TextTableOptions);
+    get content(): TextTableContent;
+    set content(value: TextTableContent);
+    get wrapMode(): "none" | "char" | "word";
+    set wrapMode(value: "none" | "char" | "word");
+    get columnWidthMode(): TextTableColumnWidthMode;
+    set columnWidthMode(value: TextTableColumnWidthMode);
+    get cellPadding(): number;
+    set cellPadding(value: number);
+    get showBorders(): boolean;
+    set showBorders(value: boolean);
+    get outerBorder(): boolean;
+    set outerBorder(value: boolean);
+    get border(): boolean;
+    set border(value: boolean);
+    get borderStyle(): BorderStyle;
+    set borderStyle(value: BorderStyle);
+    get borderColor(): RGBA;
+    set borderColor(value: ColorInput);
+    shouldStartSelection(x: number, y: number): boolean;
+    onSelectionChanged(selection: Selection | null): boolean;
+    hasSelection(): boolean;
+    getSelection(): {
+        start: number;
+        end: number;
+    } | null;
+    getSelectedText(): string;
+    protected onResize(width: number, height: number): void;
+    protected renderSelf(buffer: OptimizedBuffer): void;
+    protected destroySelf(): void;
+    private setupMeasureFunc;
+    private rebuildCells;
+    private updateCellsDiff;
+    private createCell;
+    private toStyledText;
+    private destroyCells;
+    private rebuildLayoutForCurrentWidth;
+    private computeLayout;
+    private computeColumnWidths;
+    private expandColumnWidths;
+    private fitColumnWidths;
+    private computeRowHeights;
+    private computeOffsets;
+    private applyLayoutToViews;
+    private resolveBorderLayout;
+    private getVerticalBorderCount;
+    private getHorizontalBorderCount;
+    private drawBorders;
+    private drawCells;
+    private drawCellRange;
+    private redrawSelectionRows;
+    private clearCellRange;
+    private ensureLayoutReady;
+    private getCellAtLocalPosition;
+    private applySelectionToCells;
+    private resolveSelectionResolution;
+    private getColumnAtLocalX;
+    private getFullCellSelectionCoords;
+    private findRowForLocalY;
+    private getSelectionRowRange;
+    private getDirtySelectionRowRange;
+    private resetRowSelection;
+    private resetCellSelections;
+    private createEmptyLayout;
+    private resolveLayoutWidthConstraint;
+    private getHorizontalCellPadding;
+    private getVerticalCellPadding;
+    private resolveCellPadding;
+    private invalidateLayoutAndRaster;
+    private invalidateRasterOnly;
+}