mosfez-synth/dsp-node.d.ts

A microtonal-aware synth engine library for web.

import { compile } from 'mosfez-faust/faust';

declare type ParamValue = number | string;
declare type ParamValueObject = Record<string, ParamValue>;

declare type ResolveGate<P extends ParamValueObject> = (p: Partial<P>) => number | undefined;
declare type VoiceControllerConfig<P extends ParamValueObject> = {
    polyphony: number;
    resolveGate: ResolveGate<P>;
    paramCacheSize: number;
};
declare type VoiceParam<P extends ParamValueObject> = {
    index: number;
    params: Partial<P>;
};
declare class VoiceController<P extends ParamValueObject> {
    private _polyphony;
    private _resolveGate;
    private _release;
    private _paramCacheSize;
    private _allocator;
    private _allParams;
    private _perVoiceParamsStore;
    private _recentlyAccessedIds;
    constructor(config: VoiceControllerConfig<P>);
    private _accessId;
    private _getParamsForVoice;
    private _addParamForVoice;
    private _addParamsForVoice;
    private _deleteParamsForId;
    setRelease(release: number): void;
    set({ voice, ...params }: Partial<P>): VoiceParam<P>[];
    private setWithId;
    private setAll;
}

declare type ParamDefinition = number | string;
declare type ParamDefinitionObject = Record<string, ParamDefinition>;
declare type DspNodeType = "faust" | "poly";
declare type DspNodeSerialized = DspNodeFaustSerialized | DspNodePolySerialized;
declare type DspNodeConfig = {
    type: DspNodeType;
};
declare class DspNode {
    type: DspNodeType;
    constructor(config: DspNodeConfig);
    static isFaustDspNode(DspNode: DspNode): DspNode is DspNodeFaust;
    static isPolyDspNode(DspNode: DspNode): DspNode is DspNodePoly;
    static isFaustDspNodeSerialized(serialized: DspNodeSerialized): serialized is DspNodeFaustSerialized;
    static isPolyDspNodeSerialized(serialized: DspNodeSerialized): serialized is DspNodePolySerialized;
    serialize(): DspNodeSerialized;
}
declare type DspNodeFaustDependencies = {
    compile: typeof compile;
};
declare type DspNodeFaustConfig = {
    dsp: string;
    inputs?: DspNode[];
    paramDefs: ParamDefinitionObject;
    dependencies: DspNodeFaustDependencies;
};
declare type DspNodeFaustSerialized = {
    type: "faust";
    dsp: string;
    inputs: DspNodeSerialized[];
    paramDefs: ParamDefinitionObject;
};
declare class DspNodeFaust extends DspNode {
    dsp: string;
    inputs: DspNode[];
    paramDefs: ParamDefinitionObject;
    dependencies: DspNodeFaustDependencies;
    constructor(config: DspNodeFaustConfig);
    serialize(): DspNodeFaustSerialized;
}
declare type DspNodePolyDependencies = {
    VoiceController: typeof VoiceController;
};
declare type DspNodePolyConfig = {
    input: DspNode;
    polyphony: number;
    paramCacheSize?: number;
    release: ParamDefinition;
    gate: ParamDefinition;
    dependencies: DspNodePolyDependencies;
};
declare type DspNodePolySerialized = {
    type: "poly";
    input: DspNodeSerialized;
    polyphony: number;
    paramCacheSize?: number;
    release: ParamDefinition;
    gate: ParamDefinition;
};
declare class DspNodePoly extends DspNode {
    input: DspNode;
    polyphony: number;
    paramCacheSize?: number;
    release: ParamDefinition;
    gate: ParamDefinition;
    dependencies: DspNodePolyDependencies;
    constructor(config: DspNodePolyConfig);
    serialize(): DspNodePolySerialized;
}

export { DspNode, DspNodeConfig, DspNodeFaust, DspNodeFaustConfig, DspNodeFaustDependencies, DspNodeFaustSerialized, DspNodePoly, DspNodePolyConfig, DspNodePolyDependencies, DspNodePolySerialized, DspNodeSerialized, DspNodeType, ParamDefinition, ParamDefinitionObject };