@opentui/core 0.4.2 → 0.4.4

package/Renderable.d.ts

@@ -10,8 +10,6 @@ import type { RenderContext } from "./types.js";
 declare const BrandedRenderable: unique symbol;
 export declare enum LayoutEvents {
     LAYOUT_CHANGED = "layout-changed",
-    ADDED = "added",
-    REMOVED = "removed",
     RESIZED = "resized"
 }
 export declare enum RenderableEvents {
@@ -98,7 +96,7 @@ export declare abstract class BaseRenderable extends EventEmitter {
     protected _visible: boolean;
     constructor(options: BaseRenderableOptions);
     abstract add(obj: BaseRenderable | unknown, index?: number): number;
-    abstract remove(id: string): void;
+    abstract remove(child: BaseRenderable): void;
     abstract insertBefore(obj: BaseRenderable | unknown, anchor: BaseRenderable | unknown): void;
     abstract getChildren(): BaseRenderable[];
     abstract getChildrenCount(): number;
@@ -151,7 +149,6 @@ export declare abstract class Renderable extends BaseRenderable {
     protected _position: Position;
     protected _opacity: number;
     private _flexShrink;
-    private renderableMapById;
     protected _childrenInLayoutOrder: Renderable[];
     protected _childrenInZIndexOrder: Renderable[];
     private needsZIndexSort;
@@ -164,8 +161,6 @@ export declare abstract class Renderable extends BaseRenderable {
     renderBefore?: (this: Renderable, buffer: OptimizedBuffer, deltaTime: number) => void;
     renderAfter?: (this: Renderable, buffer: OptimizedBuffer, deltaTime: number) => void;
     constructor(ctx: RenderContext, options: RenderableOptions<any>);
-    get id(): string;
-    set id(value: string);
     get focusable(): boolean;
     set focusable(value: boolean);
     get ctx(): RenderContext;
@@ -267,7 +262,7 @@ export declare abstract class Renderable extends BaseRenderable {
     add(obj: Renderable | VNode<any, any[]> | unknown, index?: number): number;
     insertBefore(obj: Renderable | VNode<any, any[]> | unknown, anchor?: Renderable | unknown): number;
     getRenderable(id: string): Renderable | undefined;
-    remove(id: string): void;
+    remove(child: BaseRenderable): void;
     protected onRemove(): void;
     getChildren(): Renderable[];
     getChildrenCount(): number;

package/audio-stream/demuxer.d.ts

@@ -0,0 +1,19 @@
+import type { AudioStreamMetadata } from "../audio.js";
+export type AudioStreamDemuxOutput<M> = {
+    type: "audio";
+    data: Uint8Array;
+} | {
+    type: "metadata";
+    metadata: M | null;
+};
+export interface AudioStreamDemuxer<M> {
+    readonly initialMetadata: M | null;
+    push(chunk: Uint8Array): Iterable<AudioStreamDemuxOutput<M>>;
+    flush(): Iterable<AudioStreamDemuxOutput<M>>;
+    abort?(reason: unknown): void;
+}
+export type AudioStreamDemuxerFactory<M> = () => AudioStreamDemuxer<M>;
+export declare function selectAudioStreamDemuxer(options: {
+    headers: Headers;
+    metadataEncoding: string;
+}): AudioStreamDemuxer<AudioStreamMetadata> | null;

package/audio-stream/icy/demuxer.d.ts

@@ -0,0 +1,21 @@
+import type { AudioStreamMetadata } from "../../audio.js";
+import type { AudioStreamDemuxer, AudioStreamDemuxOutput } from "../demuxer.js";
+export interface IcyStreamDemuxerOptions {
+    metadataInterval: number;
+    metadataEncoding?: string;
+    headers?: Readonly<Record<string, string>>;
+}
+export declare class IcyStreamDemuxer implements AudioStreamDemuxer<AudioStreamMetadata> {
+    readonly initialMetadata: AudioStreamMetadata;
+    private audioRemaining;
+    private metadata;
+    private metadataOffset;
+    private fields;
+    private readonly interval;
+    private readonly decoder;
+    private readonly headers;
+    constructor(options: IcyStreamDemuxerOptions);
+    push(chunk: Uint8Array): IterableIterator<AudioStreamDemuxOutput<AudioStreamMetadata>>;
+    flush(): IterableIterator<AudioStreamDemuxOutput<AudioStreamMetadata>>;
+}
+export declare function createIcyStreamDemuxer(options: IcyStreamDemuxerOptions): AudioStreamDemuxer<AudioStreamMetadata>;

package/audio-stream/icy/metadata.d.ts

@@ -0,0 +1 @@
+export declare function parseIcyMetadata(bytes: Uint8Array, decoder: TextDecoder): Readonly<Record<string, string>> | null;

package/audio.d.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "events";
-import type { AudioStats } from "./zig-structs.js";
+import { type AudioStreamDemuxer, type AudioStreamDemuxerFactory } from "./audio-stream/demuxer.js";
+import { type AudioStats } from "./zig-structs.js";
 export interface AudioSetupOptions {
     autoStart?: boolean;
     sampleRate?: number;
@@ -29,6 +30,119 @@ export interface AudioPlayOptions {
     loop?: boolean;
     groupId?: number;
 }
+export type AudioStreamBody = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array>;
+export type AudioStreamFormat = "mp3" | "flac";
+export interface AudioStreamContentTypeContext {
+    readonly format: AudioStreamFormat;
+    readonly contentType: string | null;
+    readonly status: number;
+    readonly url: string;
+}
+export type AudioStreamContentTypePolicy = "validate" | "ignore" | ((context: AudioStreamContentTypeContext) => boolean);
+export interface AudioStreamConnectContext {
+    readonly signal: AbortSignal;
+    readonly attempt: number;
+}
+export interface AudioStreamConnection<I = unknown> {
+    readonly body: AudioStreamBody;
+    readonly info: I;
+    close?(): void | Promise<void>;
+}
+export type AudioStreamRetryPhase = "connect" | "read";
+export interface AudioStreamRetryContext {
+    readonly attempt: number;
+    readonly maxRetries: number;
+    readonly phase: AudioStreamRetryPhase;
+}
+export type AudioStreamRetryDecision = false | {
+    readonly delayMs?: number;
+};
+export interface AudioStreamConnector<I = unknown> {
+    connect(context: AudioStreamConnectContext): Promise<AudioStreamConnection<I>>;
+}
+export interface AudioStreamBufferOptions {
+    capacityMs?: number;
+    startupMs?: number;
+    resumeMs?: number;
+}
+export interface AudioStreamReconnectOptions {
+    maxRetries?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    backoffFactor?: number;
+    retryOnEnd?: boolean;
+    retry?(error: AudioStreamError, context: AudioStreamRetryContext): AudioStreamRetryDecision;
+}
+export interface AudioStreamOptions {
+    format?: AudioStreamFormat;
+    volume?: number;
+    pan?: number;
+    groupId?: number;
+    maxProbeBytes?: number;
+    buffer?: AudioStreamBufferOptions;
+    signal?: AbortSignal;
+}
+export interface AudioStreamBodyOptions<M = AudioStreamMetadata> extends AudioStreamOptions {
+    demuxer?: AudioStreamDemuxerFactory<M>;
+    contentTypePolicy?: never;
+    request?: never;
+    reconnect?: never;
+    metadataEncoding?: never;
+}
+export interface AudioStreamSourceOptions<I = unknown, M = AudioStreamMetadata> extends AudioStreamOptions {
+    demuxer?: (info: I) => AudioStreamDemuxer<M> | null;
+    reconnect?: AudioStreamReconnectOptions;
+    contentTypePolicy?: never;
+    request?: never;
+    metadataEncoding?: never;
+}
+export interface AudioStreamUrlOptions extends AudioStreamOptions {
+    request?: Omit<RequestInit, "body" | "signal">;
+    reconnect?: AudioStreamReconnectOptions;
+    metadataEncoding?: string;
+    contentTypePolicy?: AudioStreamContentTypePolicy;
+    demuxer?: never;
+}
+export type AudioStreamState = "initializing" | "buffering" | "playing" | "reconnecting" | "ended" | "errored" | "disposed";
+export interface AudioStreamStats {
+    state: AudioStreamState;
+    sampleRate: number;
+    channels: number;
+    bufferedFrames: number;
+    capacityFrames: number;
+    bufferedDurationMs: number;
+    bytesReceived: bigint;
+    framesDecoded: bigint;
+    framesPlayed: bigint;
+    underruns: number;
+    reconnectAttempts: number;
+}
+export type AudioStreamMetadataFormat = "icy";
+export interface AudioStreamMetadata {
+    readonly format: AudioStreamMetadataFormat;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly fields: Readonly<Record<string, string>>;
+}
+export type AudioStreamAction = "fetch" | "response" | "source" | "demuxer" | "create" | "write" | "end" | "restart" | "stats" | "decoder" | "destroy" | "setVolume" | "setPan" | "setGroup";
+export interface AudioStreamErrorContext {
+    action: AudioStreamAction;
+    status?: number;
+    errorCode?: number;
+    attempt?: number;
+}
+export interface AudioStreamReconnectEvent {
+    attempt: number;
+    delayMs: number;
+    maxRetries: number;
+    error: AudioStreamError;
+}
+export interface AudioStreamEvents<M = AudioStreamMetadata> {
+    metadata: [metadata: M | null];
+    reconnecting: [event: AudioStreamReconnectEvent];
+    ended: [];
+    error: [error: Error, context: AudioStreamErrorContext];
+    disposed: [];
+}
 export type AudioGroup = number;
 export type AudioVoice = number;
 export type AudioSound = number;
@@ -49,15 +163,97 @@ export interface AudioEvents {
     stopped: [];
     disposed: [];
 }
+export type AudioInitializationAction = "resolveRenderLib" | "createAudioEngine" | "start";
+export declare class AudioInitializationError extends Error {
+    readonly action: AudioInitializationAction;
+    readonly status?: number;
+    constructor(action: AudioInitializationAction, message: string, status?: number, cause?: unknown);
+}
+export declare class AudioStreamError extends Error {
+    readonly context: AudioStreamErrorContext;
+    constructor(message: string, context: AudioStreamErrorContext, cause?: unknown);
+}
+export declare class AudioStream<M = AudioStreamMetadata> extends EventEmitter<AudioStreamEvents<M>> {
+    readonly closed: Promise<void>;
+    readonly format: AudioStreamFormat;
+    private readonly lib;
+    private readonly engine;
+    private readonly connector;
+    private readonly demuxerFactory?;
+    private readonly readAction;
+    private readonly options;
+    private readonly removeFromOwner;
+    private readonly lifecycleController;
+    private nativeStreamId;
+    private nativeStats;
+    private activeAttempt;
+    private pendingCleanup;
+    private reconnectAttempts;
+    private consecutiveReconnectAttempts;
+    private disposed;
+    private exposed;
+    private terminalError;
+    private metadata;
+    private pendingMetadataEvent;
+    private metadataEventScheduled;
+    private terminalEventScheduled;
+    private setupResolve;
+    private setupReject;
+    private closedResolve;
+    private readonly setupPromise;
+    private readonly overallAbortListener;
+    private constructor();
+    get state(): AudioStreamState;
+    private open;
+    getStats(): AudioStreamStats;
+    getMetadata(): M | null;
+    setVolume(volume: number): boolean;
+    setPan(pan: number): boolean;
+    setGroup(groupId: number): boolean;
+    private control;
+    dispose(): void;
+    private runLifecycle;
+    private createNativeStream;
+    private consumeSource;
+    private pumpSource;
+    private processDemuxOutput;
+    private writeStreamChunk;
+    private resolveConnection;
+    private beginResourceAcquisition;
+    private cleanupAttempt;
+    private performAttemptCleanup;
+    private runBoundedAttemptCleanup;
+    private retry;
+    private awaitReady;
+    private observeReady;
+    private awaitEnded;
+    private pollNativeSnapshot;
+    private snapshotError;
+    private finish;
+    private publishMetadata;
+    private emitMetadata;
+    private emitAsync;
+    private emitTerminal;
+    private isAttemptActive;
+    private stopSource;
+    private closeNativeStream;
+    private readNativeStats;
+    private toPublicStats;
+    private removeOwner;
+}
 export declare class Audio extends EventEmitter<AudioEvents> {
     static create(options?: AudioSetupOptions): Audio;
+    readonly sampleRate: number;
     private readonly lib;
     private readonly defaultStartOptions;
     private engine;
     private readonly groups;
+    private readonly streams;
     private playbackStarted;
     private mixerStarted;
+    private disposing;
     private constructor();
+    private throwAfterInitializationCleanup;
     private emitError;
     start(options?: AudioStartOptions): boolean;
     startMixer(): boolean;
@@ -69,6 +265,10 @@ export declare class Audio extends EventEmitter<AudioEvents> {
     unloadSound(sound: AudioSound): boolean;
     group(name: string): AudioGroup | null;
     play(sound: AudioSound, options?: AudioPlayOptions): AudioVoice | null;
+    playStream<M = AudioStreamMetadata>(source: AudioStreamBody, options?: AudioStreamBodyOptions<M>): Promise<AudioStream<M>>;
+    playStreamUrl(source: string | URL, options?: AudioStreamUrlOptions): Promise<AudioStream<AudioStreamMetadata>>;
+    playStreamSource<I, M = AudioStreamMetadata>(connector: AudioStreamConnector<I>, options?: AudioStreamSourceOptions<I, M>): Promise<AudioStream<M>>;
+    private openStream;
     stopVoice(voice: AudioVoice): boolean;
     setVoiceGroup(voice: AudioVoice, group: AudioGroup): boolean;
     setGroupVolume(group: AudioGroup, volume: number): boolean;