@cascadetui/core 0.1.1

package/syntax-style.d.ts

@@ -0,0 +1,54 @@
+import { RGBA, type ColorInput } from "./lib/RGBA";
+import { type RenderLib } from "./zig";
+import { type Pointer } from "bun:ffi";
+export interface StyleDefinition {
+    fg?: RGBA;
+    bg?: RGBA;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    dim?: boolean;
+}
+export interface MergedStyle {
+    fg?: RGBA;
+    bg?: RGBA;
+    attributes: number;
+}
+export interface ThemeTokenStyle {
+    scope: string[];
+    style: {
+        foreground?: ColorInput;
+        background?: ColorInput;
+        bold?: boolean;
+        italic?: boolean;
+        underline?: boolean;
+        dim?: boolean;
+    };
+}
+export declare function convertThemeToStyles(theme: ThemeTokenStyle[]): Record<string, StyleDefinition>;
+export declare class SyntaxStyle {
+    private lib;
+    private stylePtr;
+    private _destroyed;
+    private nameCache;
+    private styleDefs;
+    private mergedCache;
+    constructor(lib: RenderLib, ptr: Pointer);
+    static create(): SyntaxStyle;
+    static fromTheme(theme: ThemeTokenStyle[]): SyntaxStyle;
+    static fromStyles(styles: Record<string, StyleDefinition>): SyntaxStyle;
+    private guard;
+    registerStyle(name: string, style: StyleDefinition): number;
+    resolveStyleId(name: string): number | null;
+    getStyleId(name: string): number | null;
+    get ptr(): Pointer;
+    getStyleCount(): number;
+    clearNameCache(): void;
+    getStyle(name: string): StyleDefinition | undefined;
+    mergeStyles(...styleNames: string[]): MergedStyle;
+    clearCache(): void;
+    getCacheSize(): number;
+    getAllStyles(): Map<string, StyleDefinition>;
+    getRegisteredNames(): string[];
+    destroy(): void;
+}

package/testing/mock-keys.d.ts

@@ -0,0 +1,80 @@
+import type { CliRenderer } from "../renderer";
+export declare const KeyCodes: {
+    readonly RETURN: "\r";
+    readonly LINEFEED: "\n";
+    readonly TAB: "\t";
+    readonly BACKSPACE: "\b";
+    readonly DELETE: "\u001B[3~";
+    readonly HOME: "\u001B[H";
+    readonly END: "\u001B[F";
+    readonly ESCAPE: "\u001B";
+    readonly ARROW_UP: "\u001B[A";
+    readonly ARROW_DOWN: "\u001B[B";
+    readonly ARROW_RIGHT: "\u001B[C";
+    readonly ARROW_LEFT: "\u001B[D";
+    readonly F1: "\u001BOP";
+    readonly F2: "\u001BOQ";
+    readonly F3: "\u001BOR";
+    readonly F4: "\u001BOS";
+    readonly F5: "\u001B[15~";
+    readonly F6: "\u001B[17~";
+    readonly F7: "\u001B[18~";
+    readonly F8: "\u001B[19~";
+    readonly F9: "\u001B[20~";
+    readonly F10: "\u001B[21~";
+    readonly F11: "\u001B[23~";
+    readonly F12: "\u001B[24~";
+};
+export type KeyInput = string | keyof typeof KeyCodes;
+export interface MockKeysOptions {
+    kittyKeyboard?: boolean;
+    otherModifiersMode?: boolean;
+}
+export declare function createMockKeys(renderer: CliRenderer, options?: MockKeysOptions): {
+    pressKeys: (keys: KeyInput[], delayMs?: number) => Promise<void>;
+    pressKey: (key: KeyInput, modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    typeText: (text: string, delayMs?: number) => Promise<void>;
+    pressEnter: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressEscape: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressTab: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressBackspace: (modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressArrow: (direction: "up" | "down" | "left" | "right", modifiers?: {
+        shift?: boolean;
+        ctrl?: boolean;
+        meta?: boolean;
+        super?: boolean;
+        hyper?: boolean;
+    }) => void;
+    pressCtrlC: () => void;
+    pasteBracketedText: (text: string) => Promise<void>;
+};

package/testing/mock-mouse.d.ts

@@ -0,0 +1,38 @@
+import type { CliRenderer } from "../renderer";
+export declare const MouseButtons: {
+    readonly LEFT: 0;
+    readonly MIDDLE: 1;
+    readonly RIGHT: 2;
+    readonly WHEEL_UP: 64;
+    readonly WHEEL_DOWN: 65;
+    readonly WHEEL_LEFT: 66;
+    readonly WHEEL_RIGHT: 67;
+};
+export type MouseButton = (typeof MouseButtons)[keyof typeof MouseButtons];
+export interface MousePosition {
+    x: number;
+    y: number;
+}
+export interface MouseModifiers {
+    shift?: boolean;
+    alt?: boolean;
+    ctrl?: boolean;
+}
+export type MouseEventType = "down" | "up" | "move" | "drag" | "scroll";
+export interface MouseEventOptions {
+    button?: MouseButton;
+    modifiers?: MouseModifiers;
+    delayMs?: number;
+}
+export declare function createMockMouse(renderer: CliRenderer): {
+    moveTo: (x: number, y: number, options?: MouseEventOptions) => Promise<void>;
+    click: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    doubleClick: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    pressDown: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    release: (x: number, y: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    drag: (startX: number, startY: number, endX: number, endY: number, button?: MouseButton, options?: MouseEventOptions) => Promise<void>;
+    scroll: (x: number, y: number, direction: "up" | "down" | "left" | "right", options?: MouseEventOptions) => Promise<void>;
+    getCurrentPosition: () => MousePosition;
+    getPressedButtons: () => MouseButton[];
+    emitMouseEvent: (type: MouseEventType, x: number, y: number, button?: MouseButton, options?: Omit<MouseEventOptions, "button">) => Promise<void>;
+};

package/testing/mock-tree-sitter-client.d.ts

@@ -0,0 +1,23 @@
+import { TreeSitterClient } from "../lib/tree-sitter";
+import type { SimpleHighlight } from "../lib/tree-sitter/types";
+export declare class MockTreeSitterClient extends TreeSitterClient {
+    private _highlightPromises;
+    private _mockResult;
+    private _autoResolveTimeout?;
+    constructor(options?: {
+        autoResolveTimeout?: number;
+    });
+    highlightOnce(content: string, filetype: string): Promise<{
+        highlights?: SimpleHighlight[];
+        warning?: string;
+        error?: string;
+    }>;
+    setMockResult(result: {
+        highlights?: SimpleHighlight[];
+        warning?: string;
+        error?: string;
+    }): void;
+    resolveHighlightOnce(index?: number): void;
+    resolveAllHighlightOnce(): void;
+    isHighlighting(): boolean;
+}

package/testing/spy.d.ts

@@ -0,0 +1,7 @@
+export declare function createSpy(): {
+    (...args: any[]): void;
+    calls: any[][];
+    callCount(): number;
+    calledWith(...expected: any[]): boolean;
+    reset(): number;
+};

package/testing/test-recorder.d.ts

@@ -0,0 +1,61 @@
+import type { TestRenderer } from "./test-renderer";
+export interface RecordBuffersOptions {
+    fg?: boolean;
+    bg?: boolean;
+    attributes?: boolean;
+}
+export interface RecordedBuffers {
+    fg?: Float32Array;
+    bg?: Float32Array;
+    attributes?: Uint8Array;
+}
+export interface RecordedFrame {
+    frame: string;
+    timestamp: number;
+    frameNumber: number;
+    buffers?: RecordedBuffers;
+}
+export interface TestRecorderOptions {
+    recordBuffers?: RecordBuffersOptions;
+    now?: () => number;
+}
+/**
+ * TestRecorder records frames from a TestRenderer by hooking into the render pipeline.
+ * It captures the character frame after each native render pass.
+ */
+export declare class TestRecorder {
+    private renderer;
+    private frames;
+    private recording;
+    private frameNumber;
+    private startTime;
+    private originalRenderNative?;
+    private decoder;
+    private recordBuffers;
+    private now;
+    constructor(renderer: TestRenderer, options?: TestRecorderOptions);
+    /**
+     * Start recording frames. This hooks into the renderer's renderNative method.
+     */
+    rec(): void;
+    /**
+     * Stop recording frames and restore the original renderNative method.
+     */
+    stop(): void;
+    /**
+     * Get the recorded frames.
+     */
+    get recordedFrames(): RecordedFrame[];
+    /**
+     * Clear all recorded frames.
+     */
+    clear(): void;
+    /**
+     * Check if currently recording.
+     */
+    get isRecording(): boolean;
+    /**
+     * Capture the current frame from the renderer's buffer.
+     */
+    private captureFrame;
+}

package/testing/test-renderer.d.ts

@@ -0,0 +1,23 @@
+import { CliRenderer, type CliRendererConfig } from "../renderer";
+import { createMockKeys } from "./mock-keys";
+import { createMockMouse } from "./mock-mouse";
+import type { CapturedFrame } from "../types";
+export interface TestRendererOptions extends CliRendererConfig {
+    width?: number;
+    height?: number;
+    kittyKeyboard?: boolean;
+    otherModifiersMode?: boolean;
+}
+export interface TestRenderer extends CliRenderer {
+}
+export type MockInput = ReturnType<typeof createMockKeys>;
+export type MockMouse = ReturnType<typeof createMockMouse>;
+export declare function createTestRenderer(options: TestRendererOptions): Promise<{
+    renderer: TestRenderer;
+    mockInput: MockInput;
+    mockMouse: MockMouse;
+    renderOnce: () => Promise<void>;
+    captureCharFrame: () => string;
+    captureSpans: () => CapturedFrame;
+    resize: (width: number, height: number) => void;
+}>;

package/testing.d.ts

@@ -0,0 +1,6 @@
+export * from "./testing/test-renderer";
+export * from "./testing/mock-keys";
+export * from "./testing/mock-mouse";
+export * from "./testing/mock-tree-sitter-client";
+export * from "./testing/spy";
+export { TestRecorder, type RecordedFrame } from "./testing/test-recorder";