tone/build/esm/core/context/Param.d.ts

A Web Audio framework for making interactive music in the browser.

import { AbstractParam } from "../context/AbstractParam.js";
import { Positive, Time, UnitMap, UnitName } from "../type/Units.js";
import { Timeline } from "../util/Timeline.js";
import { ToneWithContext, ToneWithContextOptions } from "./ToneWithContext.js";
export interface ParamOptions<TypeName extends UnitName> extends ToneWithContextOptions {
    units: TypeName;
    value?: UnitMap[TypeName];
    param: AudioParam | Param<TypeName>;
    convert: boolean;
    minValue?: number;
    maxValue?: number;
    swappable?: boolean;
}
/**
 * the possible automation types
 */
type AutomationType = "linearRampToValueAtTime" | "exponentialRampToValueAtTime" | "setValueAtTime" | "setTargetAtTime" | "cancelScheduledValues";
interface TargetAutomationEvent {
    type: "setTargetAtTime";
    time: number;
    value: number;
    constant: number;
}
interface NormalAutomationEvent {
    type: Exclude<AutomationType, "setTargetAtTime">;
    time: number;
    value: number;
}
/**
 * The events on the automation
 */
export type AutomationEvent = NormalAutomationEvent | TargetAutomationEvent;
/**
 * Param wraps the native Web Audio's AudioParam to provide
 * additional unit conversion functionality. It also
 * serves as a base-class for classes which have a single,
 * automatable parameter.
 * @category Core
 */
export declare class Param<TypeName extends UnitName = "number"> extends ToneWithContext<ParamOptions<TypeName>> implements AbstractParam<TypeName> {
    readonly name: string;
    readonly input: GainNode | AudioParam;
    readonly units: UnitName;
    convert: boolean;
    overridden: boolean;
    /**
     * The timeline which tracks all of the automations.
     */
    protected _events: Timeline<AutomationEvent>;
    /**
     * The native parameter to control
     */
    protected _param: AudioParam;
    /**
     * The default value before anything is assigned
     */
    protected _initialValue: number;
    /**
     * The minimum output value
     */
    private _minOutput;
    /**
     * Private reference to the min and max values if passed into the constructor
     */
    private readonly _minValue?;
    private readonly _maxValue?;
    /**
     * If the underlying AudioParam can be swapped out
     * using the setParam method.
     */
    protected readonly _swappable: boolean;
    /**
     * @param param The AudioParam to wrap
     * @param units The unit name
     * @param convert Whether or not to convert the value to the target units
     */
    constructor(param: AudioParam, units?: TypeName, convert?: boolean);
    constructor(options: Partial<ParamOptions<TypeName>>);
    static getDefaults(): ParamOptions<any>;
    get value(): UnitMap[TypeName];
    set value(value: UnitMap[TypeName]);
    get minValue(): number;
    get maxValue(): number;
    /**
     * Type guard based on the unit name
     */
    private _is;
    /**
     * Make sure the value is always in the defined range
     */
    private _assertRange;
    /**
     * Convert the given value from the type specified by Param.units
     * into the destination value (such as Gain or Frequency).
     */
    protected _fromType(val: UnitMap[TypeName]): number;
    /**
     * Convert the parameters value into the units specified by Param.units.
     */
    protected _toType(val: number): UnitMap[TypeName];
    setValueAtTime(value: UnitMap[TypeName], time: Time): this;
    getValueAtTime(time: Time): UnitMap[TypeName];
    setRampPoint(time: Time): this;
    linearRampToValueAtTime(value: UnitMap[TypeName], endTime: Time): this;
    exponentialRampToValueAtTime(value: UnitMap[TypeName], endTime: Time): this;
    exponentialRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this;
    linearRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this;
    targetRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this;
    exponentialApproachValueAtTime(value: UnitMap[TypeName], time: Time, rampTime: Time): this;
    setTargetAtTime(value: UnitMap[TypeName], startTime: Time, timeConstant: Positive): this;
    setValueCurveAtTime(values: UnitMap[TypeName][], startTime: Time, duration: Time, scaling?: number): this;
    cancelScheduledValues(time: Time): this;
    cancelAndHoldAtTime(time: Time): this;
    rampTo(value: UnitMap[TypeName], rampTime?: Time, startTime?: Time): this;
    /**
     * Apply all of the previously scheduled events to the passed in Param or AudioParam.
     * The applied values will start at the context's current time and schedule
     * all of the events which are scheduled on this Param onto the passed in param.
     */
    apply(param: Param | AudioParam): this;
    /**
     * Replace the Param's internal AudioParam. Will apply scheduled curves
     * onto the parameter and replace the connections.
     */
    setParam(param: AudioParam): this;
    dispose(): this;
    get defaultValue(): UnitMap[TypeName];
    protected _exponentialApproach(t0: number, v0: number, v1: number, timeConstant: number, t: number): number;
    protected _linearInterpolate(t0: number, v0: number, t1: number, v1: number, t: number): number;
    protected _exponentialInterpolate(t0: number, v0: number, t1: number, v1: number, t: number): number;
}
export {};