react-native-audio-api/lib/commonjs/web-core/AudioContext.web.js

react-native-audio-api provides system for controlling audio in React Native environment compatible with Web Audio API specification

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _errors = require("../errors");
var _AnalyserNode = _interopRequireDefault(require("./AnalyserNode.web"));
var _AudioBuffer = _interopRequireDefault(require("./AudioBuffer.web"));
var _AudioBufferSourceNode = _interopRequireDefault(require("./AudioBufferSourceNode.web"));
var _AudioDestinationNode = _interopRequireDefault(require("./AudioDestinationNode.web"));
var _BiquadFilterNode = _interopRequireDefault(require("./BiquadFilterNode.web"));
var _ConvolverNode = _interopRequireDefault(require("./ConvolverNode.web"));
var _DelayNode = _interopRequireDefault(require("./DelayNode.web"));
var _GainNode = _interopRequireDefault(require("./GainNode.web"));
var _IIRFilterNode = _interopRequireDefault(require("./IIRFilterNode.web"));
var _MediaElementAudioSourceNode = _interopRequireDefault(require("./MediaElementAudioSourceNode.web"));
var _OscillatorNode = _interopRequireDefault(require("./OscillatorNode.web"));
var _PeriodicWave = _interopRequireDefault(require("./PeriodicWave.web"));
var _StereoPannerNode = _interopRequireDefault(require("./StereoPannerNode.web"));
var _ConstantSourceNode = _interopRequireDefault(require("./ConstantSourceNode.web"));
var _WaveShaperNode = _interopRequireDefault(require("./WaveShaperNode.web"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
class AudioContext {
  constructor(options) {
    if (options && options.sampleRate && (options.sampleRate < 8000 || options.sampleRate > 96000)) {
      throw new _errors.NotSupportedError(`The provided sampleRate is not supported: ${options.sampleRate}`);
    }
    this.context = new window.AudioContext({
      sampleRate: options?.sampleRate
    });
    this.sampleRate = this.context.sampleRate;
    this.destination = new _AudioDestinationNode.default(this, this.context.destination);
  }
  get currentTime() {
    return this.context.currentTime;
  }
  get state() {
    return this.context.state;
  }
  createOscillator() {
    return new _OscillatorNode.default(this);
  }
  createConstantSource() {
    return new _ConstantSourceNode.default(this);
  }
  createGain() {
    return new _GainNode.default(this);
  }
  createDelay(maxDelayTime) {
    return new _DelayNode.default(this, {
      maxDelayTime
    });
  }
  createStereoPanner() {
    return new _StereoPannerNode.default(this);
  }
  createBiquadFilter() {
    return new _BiquadFilterNode.default(this);
  }
  createConvolver() {
    return new _ConvolverNode.default(this);
  }
  createIIRFilter(feedforward, feedback) {
    return new _IIRFilterNode.default(this, {
      feedforward,
      feedback
    });
  }
  createBufferSource(options) {
    return new _AudioBufferSourceNode.default(this, options);
  }
  createMediaElementSource(mediaElement) {
    return new _MediaElementAudioSourceNode.default(this, this.context.createMediaElementSource(mediaElement), mediaElement);
  }
  createBuffer(numberOfChannels, length, sampleRate) {
    if (numberOfChannels < 1 || numberOfChannels >= 32) {
      throw new _errors.NotSupportedError(`The number of channels provided (${numberOfChannels}) is outside the range [1, 32]`);
    }
    if (length <= 0) {
      throw new _errors.NotSupportedError(`The number of frames provided (${length}) is less than or equal to the minimum bound (0)`);
    }
    if (sampleRate < 8000 || sampleRate > 96000) {
      throw new _errors.NotSupportedError(`The sample rate provided (${sampleRate}) is outside the range [8000, 96000]`);
    }
    return new _AudioBuffer.default({
      numberOfChannels,
      length,
      sampleRate
    });
  }
  createPeriodicWave(real, imag, constraints) {
    if (real.length !== imag.length) {
      throw new _errors.InvalidAccessError(`The lengths of the real (${real.length}) and imaginary (${imag.length}) arrays must match.`);
    }
    return new _PeriodicWave.default(this, {
      real,
      imag,
      ...constraints
    });
  }
  createAnalyser() {
    return new _AnalyserNode.default(this);
  }
  createWaveShaper() {
    return new _WaveShaperNode.default(this, this.context.createWaveShaper());
  }
  async decodeAudioData(source, fetchOptions) {
    if (source instanceof ArrayBuffer) {
      const decodedData = await this.context.decodeAudioData(source);
      return new _AudioBuffer.default(decodedData);
    }
    if (typeof source === 'string') {
      const response = await fetch(source, fetchOptions);
      if (!response.ok) {
        throw new _errors.InvalidAccessError(`Failed to fetch audio data from the provided source: ${source}`);
      }
      const arrayBuffer = await response.arrayBuffer();
      const decodedData = await this.context.decodeAudioData(arrayBuffer);
      return new _AudioBuffer.default(decodedData);
    }
    throw new TypeError('Unsupported source for decodeAudioData: ' + source);
  }
  async close() {
    await this.context.close();
  }
  async resume() {
    await this.context.resume();
  }
  async suspend() {
    await this.context.suspend();
  }
}
exports.default = AudioContext;
//# sourceMappingURL=AudioContext.web.js.map