cacophony 0.30.3 → 0.30.4

package/dist/basePlayback.d.ts

@@ -0,0 +1,98 @@
+import { Bus } from './bus';
+import { FadeType } from './cacophony';
+import { PlaybackContainer } from './container';
+import { AudioNode, BaseContext, BiquadFilterNode, GainNode } from './context';
+import { EffectChain } from './effectChain';
+import { CacophonyEffect } from './effects';
+import { TypedEventEmitter } from './eventEmitter';
+import { PlaybackEvents } from './events';
+import { FilterManager } from './filters';
+export type PlaybackState = "unplayed" | "playing" | "paused" | "stopped";
+declare const BasePlayback_base: (abstract new (...args: any[]) => {
+    panner?: import('./context').PannerNode | import('./context').StereoPannerNode | undefined;
+    _panType: import('./cacophony').PanType;
+    readonly panType: import('./cacophony').PanType;
+    setPanType(panType: import('./cacophony').PanType, audioContext: BaseContext): void;
+    setPannerNode(pannerNode: import('./context').PannerNode): void;
+    get stereoPan(): number | null;
+    set stereoPan(value: number);
+    get threeDOptions(): import('./pannerMixin').ThreeDOptions;
+    set threeDOptions(options: import('./pannerMixin').ThreeDOptions | Partial<import('./pannerMixin').HrtfPannerOptions>);
+    position: import('./cacophony').Position;
+    cleanup(): void;
+    _filters: BiquadFilterNode[];
+    addFilter(filter: BiquadFilterNode): void;
+    removeFilter(filter: BiquadFilterNode): void;
+    readonly filters: BiquadFilterNode[];
+    addFilters(filters: BiquadFilterNode[]): void;
+}) & typeof FilterManager & (abstract new (...args: any[]) => import('./volumeMixin').VolumeControls);
+export declare abstract class BasePlayback extends BasePlayback_base {
+    source?: AudioNode;
+    protected _effectChain?: EffectChain;
+    private _effectContext?;
+    /**
+     * Per-playback send-gain allocations owned by the shared routing state
+     * machine. Cleanup disconnects every allocation deterministically.
+     */
+    _sendGains: Map<Bus, GainNode>;
+    protected _state: PlaybackState;
+    origin: PlaybackContainer;
+    eventEmitter: TypedEventEmitter<PlaybackEvents>;
+    constructor(origin: PlaybackContainer);
+    protected setEffectChainEndpoints(input: AudioNode, output: AudioNode): void;
+    /** Build and splice an effect into this live playback's pre-panner chain. */
+    addEffect(effect: CacophonyEffect): Promise<AudioNode>;
+    /** @internal Source preplay path that preserves synchronous native-build failures. */
+    _addSourceEffect(effect: CacophonyEffect): Promise<AudioNode>;
+    /** @internal Materialize a source-level biquad recipe and retain filter API compatibility. */
+    _addFilterEffect(effect: CacophonyEffect): Promise<AudioNode>;
+    private materializeEffect;
+    rampEffectParam(handle: AudioNode, paramName: string, value: number, options?: {
+        duration?: number;
+        type?: FadeType;
+    }): void;
+    addFilter(filter: BiquadFilterNode): void;
+    removeFilter(filter: BiquadFilterNode): void;
+    setFilterOrder(filters: readonly BiquadFilterNode[]): void;
+    setFilterBypassed(filter: BiquadFilterNode, bypassed: boolean): void;
+    isFilterBypassed(filter: BiquadFilterNode): boolean;
+    rampFilterParam(filter: BiquadFilterNode, paramName: string, value: number, options?: {
+        duration?: number;
+        type?: FadeType;
+    }): void;
+    abstract play(): [this];
+    abstract pause(): void;
+    abstract stop(): void;
+    /**
+     * Checks if the audio is currently playing.
+     */
+    get isPlaying(): boolean;
+    get isPaused(): boolean;
+    protected markPlaying(): void;
+    protected markPaused(): void;
+    protected markStopped(): void;
+    protected emitPlayStarted(isResume: boolean): void;
+    protected emitPaused(): void;
+    protected emitStopped(): void;
+    /**
+     * Register event listener.
+     * @returns Cleanup function
+     */
+    on<K extends keyof PlaybackEvents>(event: K, listener: (data: PlaybackEvents[K]) => void): () => void;
+    /**
+     * Remove event listener.
+     */
+    off<K extends keyof PlaybackEvents>(event: K, listener: (data: PlaybackEvents[K]) => void): void;
+    emit<K extends keyof PlaybackEvents>(event: K, data: PlaybackEvents[K]): void;
+    emitAsync<K extends keyof PlaybackEvents>(event: K, data: PlaybackEvents[K]): Promise<void>;
+    /**
+     * Fades the volume to a target value, emitting fadeStart and fadeEnd events.
+     */
+    fadeTo(value: number, duration: number, type?: FadeType): Promise<void>;
+    /**
+     * Cancels any in-progress fade, emitting fadeCancel if a fade was active.
+     */
+    cancelFade(): void;
+    cleanup(): void;
+}
+export {};