react-native-audio-api 0.4.8 → 0.4.10-rc.1

package/src/core/AudioNode.ts

@@ -22,7 +22,7 @@ export default class AudioNode {
     this.channelInterpretation = this.node.channelInterpretation;
   }
 
-  public connect(destination: AudioNode): void {
+  public connect(destination: AudioNode): AudioNode {
     if (this.context !== destination.context) {
       throw new InvalidAccessError(
         'The AudioNodes are from different BaseAudioContexts'
@@ -30,6 +30,8 @@ export default class AudioNode {
     }
 
     this.node.connect(destination.node);
+
+    return destination;
   }
 
   public disconnect(destination?: AudioNode): void {

package/src/core/AudioParam.ts

@@ -1,5 +1,5 @@
 import { IAudioParam } from '../interfaces';
-import { RangeError } from '../errors';
+import { RangeError, InvalidStateError } from '../errors';
 
 export default class AudioParam {
   readonly defaultValue: number;
@@ -23,81 +23,114 @@ export default class AudioParam {
     this.audioParam.value = value;
   }
 
-  public setValueAtTime(value: number, startTime: number): void {
+  public setValueAtTime(value: number, startTime: number): AudioParam {
     if (startTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${startTime}`
+        `startTime must be a finite non-negative number: ${startTime}`
       );
     }
 
     this.audioParam.setValueAtTime(value, startTime);
+
+    return this;
   }
 
-  public linearRampToValueAtTime(value: number, endTime: number): void {
+  public linearRampToValueAtTime(value: number, endTime: number): AudioParam {
     if (endTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${endTime}`
+        `endTime must be a finite non-negative number: ${endTime}`
       );
     }
 
     this.audioParam.linearRampToValueAtTime(value, endTime);
+
+    return this;
   }
 
-  public exponentialRampToValueAtTime(value: number, endTime: number): void {
+  public exponentialRampToValueAtTime(
+    value: number,
+    endTime: number
+  ): AudioParam {
     if (endTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${endTime}`
+        `endTime must be a finite non-negative number: ${endTime}`
       );
     }
 
     this.audioParam.exponentialRampToValueAtTime(value, endTime);
+
+    return this;
   }
 
   public setTargetAtTime(
     target: number,
     startTime: number,
     timeConstant: number
-  ): void {
+  ): AudioParam {
     if (startTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${startTime}`
+        `startTime must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    if (timeConstant < 0) {
+      throw new RangeError(
+        `timeConstant must be a finite non-negative number: ${startTime}`
       );
     }
 
     this.audioParam.setTargetAtTime(target, startTime, timeConstant);
+
+    return this;
   }
 
   public setValueCurveAtTime(
     values: number[],
     startTime: number,
     duration: number
-  ): void {
+  ): AudioParam {
     if (startTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${startTime}`
+        `startTime must be a finite non-negative number: ${startTime}`
       );
     }
 
+    if (duration < 0) {
+      throw new RangeError(
+        `duration must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    if (values.length < 2) {
+      throw new InvalidStateError(`values must contain at least two values`);
+    }
+
     this.audioParam.setValueCurveAtTime(values, startTime, duration);
+
+    return this;
   }
 
-  public cancelScheduledValues(cancelTime: number): void {
+  public cancelScheduledValues(cancelTime: number): AudioParam {
     if (cancelTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${cancelTime}`
+        `cancelTime must be a finite non-negative number: ${cancelTime}`
       );
     }
 
     this.audioParam.cancelScheduledValues(cancelTime);
+
+    return this;
   }
 
-  public cancelAndHoldAtTime(cancelTime: number): void {
+  public cancelAndHoldAtTime(cancelTime: number): AudioParam {
     if (cancelTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${cancelTime}`
+        `cancelTime must be a finite non-negative number: ${cancelTime}`
       );
     }
 
     this.audioParam.cancelAndHoldAtTime(cancelTime);
+
+    return this;
   }
 }

package/src/core/BaseAudioContext.ts

@@ -9,7 +9,7 @@ import AudioBufferSourceNode from './AudioBufferSourceNode';
 import AudioBuffer from './AudioBuffer';
 import PeriodicWave from './PeriodicWave';
 import AnalyserNode from './AnalyserNode';
-import { InvalidAccessError } from '../errors';
+import { InvalidAccessError, NotSupportedError } from '../errors';
 
 export default class BaseAudioContext {
   readonly destination: AudioDestinationNode;
@@ -56,20 +56,20 @@ export default class BaseAudioContext {
     sampleRate: number
   ): AudioBuffer {
     if (numOfChannels < 1 || numOfChannels >= 32) {
-      throw new RangeError(
+      throw new NotSupportedError(
         `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
       );
     }
 
     if (length <= 0) {
-      throw new RangeError(
+      throw new NotSupportedError(
         `The number of frames provided (${length}) is less than or equal to the minimum bound (0)`
       );
     }
 
-    if (sampleRate <= 0) {
-      throw new RangeError(
-        `The sample rate provided (${sampleRate}) is outside the range [3000, 768000]`
+    if (sampleRate < 8000 || sampleRate > 96000) {
+      throw new NotSupportedError(
+        `The sample rate provided (${sampleRate}) is outside the range [8000, 96000]`
       );
     }
 
@@ -106,15 +106,8 @@ export default class BaseAudioContext {
       sourcePath = sourcePath.replace('file://', '');
     }
 
-    try {
-      const buffer = await this.context.decodeAudioDataSource(sourcePath);
-      return new AudioBuffer(buffer);
-    } catch (error) {
-      // Handle error gracefully, for example log it or throw it further with a custom message
-      console.error('Error decoding audio data source:', error);
-      throw new Error(
-        `Failed to decode audio data from source: ${sourcePath}.`
-      );
-    }
+    return new AudioBuffer(
+      await this.context.decodeAudioDataSource(sourcePath)
+    );
   }
 }

package/src/errors/NotSupportedError.tsx

@@ -0,0 +1,8 @@
+class NotSupportedError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NotSupportedError';
+  }
+}
+
+export default NotSupportedError;

package/src/errors/index.ts

@@ -2,3 +2,4 @@ export { default as IndexSizeError } from './IndexSizeError';
 export { default as InvalidAccessError } from './InvalidAccessError';
 export { default as InvalidStateError } from './InvalidStateError';
 export { default as RangeError } from './RangeError';
+export { default as NotSupportedError } from './NotSupportedError';

package/src/index.ts

@@ -33,4 +33,5 @@ export {
   InvalidAccessError,
   InvalidStateError,
   RangeError,
+  NotSupportedError,
 } from './errors';

package/src/interfaces.ts

@@ -33,7 +33,7 @@ export interface IBaseAudioContext {
 }
 
 export interface IAudioContext extends IBaseAudioContext {
-  close(): void;
+  close(): Promise<undefined>;
 }
 
 export interface IAudioNode {

package/src/types.ts

@@ -12,7 +12,7 @@ export type BiquadFilterType =
   | 'notch'
   | 'allpass';
 
-export type ContextState = 'running' | 'closed';
+export type ContextState = 'running' | 'closed' | `suspended`;
 
 export type OscillatorType =
   | 'sine'
@@ -25,4 +25,8 @@ export interface PeriodicWaveConstraints {
   disableNormalization: boolean;
 }
 
+export interface AudioContextOptions {
+  sampleRate: number;
+}
+
 export type WindowType = 'blackman' | 'hann';

package/src/web-core/AudioContext.tsx

@@ -1,5 +1,9 @@
-import { ContextState, PeriodicWaveConstraints } from '../types';
-import { RangeError, InvalidAccessError } from '../errors';
+import {
+  ContextState,
+  PeriodicWaveConstraints,
+  AudioContextOptions,
+} from '../types';
+import { InvalidAccessError, NotSupportedError } from '../errors';
 import BaseAudioContext from './BaseAudioContext';
 import AnalyserNode from './AnalyserNode';
 import AudioDestinationNode from './AudioDestinationNode';
@@ -17,8 +21,14 @@ export default class AudioContext implements BaseAudioContext {
   readonly destination: AudioDestinationNode;
   readonly sampleRate: number;
 
-  constructor(_sampleRate?: number) {
-    this.context = new window.AudioContext();
+  constructor(options?: AudioContextOptions) {
+    if (options && (options.sampleRate < 8000 || options.sampleRate > 96000)) {
+      throw new NotSupportedError(
+        `The provided sampleRate is not supported: ${options.sampleRate}`
+      );
+    }
+
+    this.context = new window.AudioContext(options);
 
     this.sampleRate = this.context.sampleRate;
     this.destination = new AudioDestinationNode(this, this.context.destination);
@@ -58,20 +68,20 @@ export default class AudioContext implements BaseAudioContext {
     sampleRate: number
   ): AudioBuffer {
     if (numOfChannels < 1 || numOfChannels >= 32) {
-      throw new RangeError(
+      throw new NotSupportedError(
         `The number of channels provided (${numOfChannels}) is outside the range [1, 32]`
       );
     }
 
     if (length <= 0) {
-      throw new RangeError(
+      throw new NotSupportedError(
         `The number of frames provided (${length}) is less than or equal to the minimum bound (0)`
       );
     }
 
-    if (sampleRate <= 0) {
-      throw new RangeError(
-        `The sample rate provided (${sampleRate}) is outside the range [3000, 768000]`
+    if (sampleRate < 8000 || sampleRate > 96000) {
+      throw new NotSupportedError(
+        `The sample rate provided (${sampleRate}) is outside the range [8000, 96000]`
       );
     }
 
@@ -108,7 +118,7 @@ export default class AudioContext implements BaseAudioContext {
     return new AudioBuffer(await this.context.decodeAudioData(arrayBuffer));
   }
 
-  async close(): Promise<void> {
+  async close(): Promise<undefined> {
     await this.context.close();
   }
 }

package/src/web-core/AudioNode.tsx

@@ -21,12 +21,14 @@ export default class AudioNode {
     this.channelInterpretation = this.node.channelInterpretation;
   }
 
-  public connect(destination: AudioNode): void {
+  public connect(destination: AudioNode): AudioNode {
     if (this.context !== destination.context) {
       throw new Error('The AudioNodes are from different BaseAudioContexts');
     }
 
     this.node.connect(destination.node);
+
+    return destination;
   }
 
   public disconnect(destination?: AudioNode): void {

package/src/web-core/AudioParam.tsx

@@ -1,4 +1,4 @@
-import { RangeError } from '../errors';
+import { RangeError, InvalidStateError } from '../errors';
 
 export default class AudioParam {
   readonly defaultValue: number;
@@ -22,85 +22,118 @@ export default class AudioParam {
     this.param.value = value;
   }
 
-  public setValueAtTime(value: number, startTime: number): void {
+  public setValueAtTime(value: number, startTime: number): AudioParam {
     if (startTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${startTime}`
+        `startTime must be a finite non-negative number: ${startTime}`
       );
     }
 
     this.param.setValueAtTime(value, startTime);
+
+    return this;
   }
 
-  public linearRampToValueAtTime(value: number, endTime: number): void {
+  public linearRampToValueAtTime(value: number, endTime: number): AudioParam {
     if (endTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${endTime}`
+        `endTime must be a finite non-negative number: ${endTime}`
       );
     }
 
     this.param.linearRampToValueAtTime(value, endTime);
+
+    return this;
   }
 
-  public exponentialRampToValueAtTime(value: number, endTime: number): void {
+  public exponentialRampToValueAtTime(
+    value: number,
+    endTime: number
+  ): AudioParam {
     if (endTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${endTime}`
+        `endTime must be a finite non-negative number: ${endTime}`
       );
     }
 
     this.param.exponentialRampToValueAtTime(value, endTime);
+
+    return this;
   }
 
   public setTargetAtTime(
     target: number,
     startTime: number,
     timeConstant: number
-  ): void {
+  ): AudioParam {
     if (startTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${startTime}`
+        `startTime must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    if (timeConstant < 0) {
+      throw new RangeError(
+        `timeConstant must be a finite non-negative number: ${startTime}`
       );
     }
 
     this.param.setTargetAtTime(target, startTime, timeConstant);
+
+    return this;
   }
 
   public setValueCurveAtTime(
     values: number[],
     startTime: number,
     duration: number
-  ): void {
+  ): AudioParam {
     if (startTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${startTime}`
+        `startTime must be a finite non-negative number: ${startTime}`
       );
     }
 
+    if (duration < 0) {
+      throw new RangeError(
+        `duration must be a finite non-negative number: ${startTime}`
+      );
+    }
+
+    if (values.length < 2) {
+      throw new InvalidStateError(`values must contain at least two values`);
+    }
+
     this.param.setValueCurveAtTime(
       new Float32Array(values),
       startTime,
       duration
     );
+
+    return this;
   }
 
-  public cancelScheduledValues(cancelTime: number): void {
+  public cancelScheduledValues(cancelTime: number): AudioParam {
     if (cancelTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${cancelTime}`
+        `cancelTime must be a finite non-negative number: ${cancelTime}`
       );
     }
 
     this.param.cancelScheduledValues(cancelTime);
+
+    return this;
   }
 
-  public cancelAndHoldAtTime(cancelTime: number): void {
+  public cancelAndHoldAtTime(cancelTime: number): AudioParam {
     if (cancelTime < 0) {
       throw new RangeError(
-        `Time must be a finite non-negative number: ${cancelTime}`
+        `cancelTime must be a finite non-negative number: ${cancelTime}`
       );
     }
 
     this.param.cancelAndHoldAtTime(cancelTime);
+
+    return this;
   }
 }