@opentui/core 0.4.4 → 0.5.0

package/README.md

@@ -4,11 +4,11 @@ OpenTUI is a native terminal UI core written in Zig with TypeScript bindings. Th
 
 ## Documentation
 
-- [Getting Started](docs/getting-started.md) - API and usage guide
+- [Getting Started](https://opentui.com/docs/getting-started) - API and usage guide
 - [Development Guide](docs/development.md) - Building, testing, and contributing
-- [Tree-Sitter](docs/tree-sitter.md) - Syntax highlighting integration
-- [Renderables vs Constructs](docs/renderables-vs-constructs.md) - Understanding the component model
-- [Environment Variables](docs/env-vars.md) - Configuration options
+- [Tree-Sitter](https://opentui.com/docs/reference/tree-sitter) - Syntax highlighting integration
+- [Renderables vs Constructs](https://opentui.com/docs/core-concepts/renderables-vs-constructs) - Understanding the component model
+- [Environment Variables](https://opentui.com/docs/reference/env-vars) - Configuration options
 
 ## Install
 

package/Renderable.d.ts

@@ -332,10 +332,13 @@ interface RenderCommandPopOpacity extends RenderCommandBase {
 export type RenderCommand = RenderCommandPushScissorRect | RenderCommandPopScissorRect | RenderCommandRender | RenderCommandPushOpacity | RenderCommandPopOpacity;
 export declare class RootRenderable extends Renderable {
     private renderList;
+    private _currentRenderable;
     private appliedLayoutGeneration;
     private appliedRenderListRevision;
     private renderListReusable;
     constructor(ctx: RenderContext);
+    get currentRenderable(): Renderable | undefined;
+    takeCurrentRenderable(): Renderable | undefined;
     render(buffer: OptimizedBuffer, deltaTime: number): void;
     protected propagateLiveCount(delta: number): void;
     calculateLayout(): void;

package/audio.d.ts

@@ -151,7 +151,68 @@ export interface AudioPlaybackDevice {
     name: string;
     isDefault: boolean;
 }
-export type AudioAction = "createAudioEngine" | "start" | "startMixer" | "stop" | "loadSound" | "loadSoundFile" | "unloadSound" | "group" | "play" | "stopVoice" | "setVoiceGroup" | "setGroupVolume" | "setMasterVolume" | "mixFrames" | "enableTap" | "readTapFrames" | "listPlaybackDevices" | "selectPlaybackDevice" | "clearPlaybackDeviceSelection" | "getStats";
+export interface AudioCaptureDevice {
+    index: number;
+    name: string;
+    isDefault: boolean;
+}
+export interface AudioCaptureOptions {
+    channels?: number;
+    capacityFrames?: number;
+    startOptions?: AudioStartOptions;
+}
+export interface AudioCaptureStreamOptions extends AudioCaptureOptions {
+    chunkFrames?: number;
+    signal?: AbortSignal;
+}
+export type AudioCaptureStreamState = "initializing" | "capturing" | "stopping" | "stopped" | "errored" | "disposed";
+export type AudioCaptureStreamAction = "start" | "read" | "stop" | "stats" | "destroy";
+export interface AudioCaptureStreamErrorContext {
+    action: AudioCaptureStreamAction;
+    status?: number;
+}
+export interface AudioCaptureStreamEvents {
+    stopped: [];
+    error: [error: AudioCaptureStreamError, context: AudioCaptureStreamErrorContext];
+    disposed: [];
+}
+export interface AudioCaptureStats {
+    sampleRate: number;
+    channels: number;
+    capacityFrames: number;
+    bufferedFrames: number;
+    framesReceived: bigint;
+    framesRead: bigint;
+    framesDropped: bigint;
+}
+export interface AudioCaptureStreamStats extends AudioCaptureStats {
+    state: AudioCaptureStreamState;
+    bufferedDurationMs: number;
+}
+export interface AudioCaptureReadResult {
+    frames: Float32Array;
+    framesRead: number;
+}
+export type AudioRecordToFileOptions = AudioCaptureStreamOptions;
+export type AudioRecorderState = "initializing" | "recording" | "stopping" | "stopped" | "errored" | "disposed";
+export type AudioRecorderAction = "open" | "start" | "read" | "write" | "stop" | "finalize" | "publish" | "stats" | "destroy";
+export interface AudioRecorderErrorContext {
+    action: AudioRecorderAction;
+    status?: number;
+}
+export interface AudioRecorderEvents {
+    stopped: [];
+    error: [error: AudioRecorderError, context: AudioRecorderErrorContext];
+    disposed: [];
+}
+export interface AudioRecorderStats extends AudioCaptureStats {
+    state: AudioRecorderState;
+    bufferedDurationMs: number;
+    framesWritten: bigint;
+    dataBytesWritten: bigint;
+    durationMs: number;
+}
+export type AudioAction = "createAudioEngine" | "start" | "startMixer" | "stop" | "loadSound" | "loadSoundFile" | "unloadSound" | "group" | "play" | "stopVoice" | "setVoiceGroup" | "setGroupVolume" | "setMasterVolume" | "mixFrames" | "enableTap" | "readTapFrames" | "listPlaybackDevices" | "selectPlaybackDevice" | "clearPlaybackDeviceSelection" | "listCaptureDevices" | "selectCaptureDevice" | "clearCaptureDeviceSelection" | "startCapture" | "readCaptureFrames" | "getCaptureStats" | "stopCapture" | "getStats";
 export interface AudioErrorContext {
     action: AudioAction;
     status?: number;
@@ -160,6 +221,8 @@ export interface AudioEvents {
     error: [error: Error, context: AudioErrorContext];
     started: [];
     mixerStarted: [];
+    captureStarted: [];
+    captureStopped: [];
     stopped: [];
     disposed: [];
 }
@@ -169,6 +232,14 @@ export declare class AudioInitializationError extends Error {
     readonly status?: number;
     constructor(action: AudioInitializationAction, message: string, status?: number, cause?: unknown);
 }
+export declare class AudioCaptureStreamError extends Error {
+    readonly context: AudioCaptureStreamErrorContext;
+    constructor(message: string, context: AudioCaptureStreamErrorContext, cause?: unknown);
+}
+export declare class AudioRecorderError extends Error {
+    readonly context: AudioRecorderErrorContext;
+    constructor(message: string, context: AudioRecorderErrorContext, cause?: unknown);
+}
 export declare class AudioStreamError extends Error {
     readonly context: AudioStreamErrorContext;
     constructor(message: string, context: AudioStreamErrorContext, cause?: unknown);
@@ -241,6 +312,113 @@ export declare class AudioStream<M = AudioStreamMetadata> extends EventEmitter<A
     private toPublicStats;
     private removeOwner;
 }
+export declare class AudioCaptureStream extends EventEmitter<AudioCaptureStreamEvents> {
+    readonly readable: ReadableStream<Float32Array>;
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly chunkFrames: number;
+    readonly closed: Promise<void>;
+    private readonly init;
+    private readonly lifecycleController;
+    private streamController;
+    private nativeStats;
+    private currentState;
+    private pendingFrames;
+    private readonly pendingSamples;
+    private producerStopAttempted;
+    private producerStopped;
+    private producerMayBeRunning;
+    private ownerRemoved;
+    private exposed;
+    private terminal;
+    private discardRequested;
+    private discardDecisionScheduled;
+    private pumpPromise;
+    private producerCleanupPromise;
+    private lastCleanupFailure;
+    private terminalCompletionPromise;
+    private closedResolve;
+    private readonly signalAbortListener;
+    private constructor();
+    get state(): AudioCaptureStreamState;
+    private open;
+    getStats(): AudioCaptureStreamStats;
+    stop(): void;
+    dispose(): void;
+    private disposeInternal;
+    private pull;
+    private pump;
+    private pumpSource;
+    private discardNativeRing;
+    private requestDiscardDrain;
+    private scheduleDiscardIfIdle;
+    private refreshStats;
+    private observeProducer;
+    private stopProducer;
+    private finishStopped;
+    private fail;
+    private operationError;
+    private cleanupProducer;
+    private retryTerminalCleanup;
+    private publicStats;
+    private refreshFinalStats;
+    private removeOwner;
+    private emitTerminal;
+}
+export declare class AudioRecorder extends EventEmitter<AudioRecorderEvents> {
+    private static readonly fileSystem;
+    readonly filePath: string;
+    readonly format: "wav";
+    readonly sampleRate: number;
+    readonly channels: number;
+    readonly closed: Promise<void>;
+    private readonly init;
+    private currentState;
+    private capture;
+    private reader;
+    private fileHandle;
+    private tempPath;
+    private captureStats;
+    private framesWritten;
+    private dataBytesWritten;
+    private stopRequested;
+    private terminal;
+    private terminationRequest;
+    private publicationStarted;
+    private exposed;
+    private ownerRemoved;
+    private cleanupPromise;
+    private resourceCleanupPromise;
+    private retainedCleanupScheduled;
+    private lifecyclePromise;
+    private closedResolve;
+    private readonly signalAbortListener;
+    private readonly captureErrorListener;
+    private constructor();
+    get state(): AudioRecorderState;
+    private open;
+    getStats(): AudioRecorderStats;
+    stop(): void;
+    dispose(): void;
+    private consume;
+    private writeSamples;
+    private readWithStats;
+    private complete;
+    private publish;
+    private fail;
+    private requestTermination;
+    private finishCleanup;
+    private cleanupOwnedResources;
+    private retryRetainedCleanup;
+    private scheduleRetainedCleanup;
+    private hasRetainedResources;
+    private openTemporaryFile;
+    private writeFully;
+    private ensureOpening;
+    private fromCaptureError;
+    private removeOwner;
+    private emitTerminal;
+}
 export declare class Audio extends EventEmitter<AudioEvents> {
     static create(options?: AudioSetupOptions): Audio;
     readonly sampleRate: number;
@@ -251,6 +429,13 @@ export declare class Audio extends EventEmitter<AudioEvents> {
     private readonly streams;
     private playbackStarted;
     private mixerStarted;
+    private captureStarted;
+    private captureDeviceOpen;
+    private captureBufferAvailable;
+    private captureChannels;
+    private captureCapacityFrames;
+    private captureOwner;
+    private captureStream;
     private disposing;
     private constructor();
     private throwAfterInitializationCleanup;
@@ -283,6 +468,22 @@ export declare class Audio extends EventEmitter<AudioEvents> {
     listPlaybackDevices(): AudioPlaybackDevice[] | null;
     selectPlaybackDevice(index: number): boolean;
     clearPlaybackDeviceSelection(): void;
+    openCapture(options?: AudioCaptureStreamOptions): Promise<AudioCaptureStream>;
+    recordToFile(filePath: string, options?: AudioRecordToFileOptions): Promise<AudioRecorder>;
+    listCaptureDevices(): AudioCaptureDevice[] | null;
+    selectCaptureDevice(index: number): boolean;
+    clearCaptureDeviceSelection(): void;
+    startCapture(options?: AudioCaptureOptions): boolean;
+    isCapturing(): boolean;
+    private isCapturingInternal;
+    readCaptureFrames(frameCount: number): AudioCaptureReadResult | null;
+    getCaptureStats(): AudioCaptureStats | null;
+    stopCapture(): boolean;
+    private emitCaptureOwnershipError;
+    private startCaptureInternal;
+    private readCaptureInternal;
+    private getCaptureStatsInternal;
+    private stopCaptureInternal;
     getStats(): AudioStats | null;
     dispose(): void;
 }

package/buffer.d.ts

@@ -1,6 +1,8 @@
 import { RGBA } from "./lib/index.js";
 import { type OptimizedBufferHandle, type RenderLib } from "./zig.js";
 import { type Pointer, type PointerInput } from "./platform/ffi.js";
+import type { NativeImage } from "./image.js";
+import type { ImageRenderProtocol } from "./types.js";
 import { type BorderStyle, type BorderSides } from "./lib/index.js";
 import { TargetChannel, type WidthMethod, type CapturedLine } from "./types.js";
 import type { TextBufferView } from "./text-buffer-view.js";
@@ -58,6 +60,7 @@ export declare class OptimizedBuffer {
     drawTextBuffer(textBufferView: TextBufferView, x: number, y: number): void;
     drawEditorView(editorView: EditorView, x: number, y: number): void;
     drawSuperSampleBuffer(x: number, y: number, pixelDataPtr: PointerInput, pixelDataLength: number, format: "bgra8unorm" | "rgba8unorm", alignedBytesPerRow: number): void;
+    drawImage(image: NativeImage, x: number, y: number, width: number, height: number, pixelWidth?: number, pixelHeight?: number, sourceX?: number, sourceY?: number, sourceWidth?: number, sourceHeight?: number, protocol?: ImageRenderProtocol): boolean;
     drawPackedBuffer(dataPtr: PointerInput, dataLen: number, posX: number, posY: number, terminalWidthCells: number, terminalHeightCells: number): void;
     drawGrayscaleBuffer(posX: number, posY: number, intensities: Float32Array, srcWidth: number, srcHeight: number, fg?: RGBA | null, bg?: RGBA | null): void;
     drawGrayscaleBufferSupersampled(posX: number, posY: number, intensities: Float32Array, srcWidth: number, srcHeight: number, fg?: RGBA | null, bg?: RGBA | null): void;