react-native-audio-api/lib/module/core/AudioFileUtils.js

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

"use strict";

import { AudioApiError } from "../errors/index.js";
import { headersFromRequestInit } from "../utils/index.js";
import { isBase64Source, isDataBlobString, isRemoteSource, resolveLocalFilePath } from "../utils/paths.js";
class AudioFileUtils {
  static instance = null;
  constructor() {
    this.fileUtils = globalThis.createAudioFileUtils();
  }
  static getInstance() {
    if (!AudioFileUtils.instance) {
      AudioFileUtils.instance = new AudioFileUtils();
    }
    return AudioFileUtils.instance;
  }
  async concatAudioFilesInstance(inputPaths, outputPath) {
    if (!Array.isArray(inputPaths) || inputPaths.length === 0) {
      throw new AudioApiError('concatAudioFiles requires at least one input path.');
    }
    if (inputPaths.some(inputPath => typeof inputPath !== 'string')) {
      throw new TypeError('concatAudioFiles input paths must be strings.');
    }
    if (typeof outputPath !== 'string' || outputPath.length === 0) {
      throw new AudioApiError('concatAudioFiles requires an output path.');
    }
    return this.fileUtils.concatAudioFiles(inputPaths, outputPath);
  }
  async probeDurationInstance(input, sampleRate, headers) {
    return this.fileUtils.probeDuration(input, sampleRate, headers);
  }
  async getAudioDurationInstance(input, fetchOptions) {
    let duration;
    if (input instanceof ArrayBuffer) {
      duration = await this.probeDurationInstance(input);
    } else if (typeof input !== 'string') {
      throw new TypeError('Input must be a local file path, remote URL, or ArrayBuffer.');
    } else {
      if (isBase64Source(input)) {
        throw new AudioApiError('Base64 source decoding is not currently supported, to decode raw PCM base64 strings use decodePCMInBase64 method.');
      }
      if (isDataBlobString(input)) {
        throw new AudioApiError('Data Blob string decoding is not currently supported.');
      }
      const headers = headersFromRequestInit(fetchOptions);
      const source = isRemoteSource(input) ? input : resolveLocalFilePath(input);
      duration = await this.probeDurationInstance(source, 0, headers);
    }
    if (duration === null) {
      throw new AudioApiError('Audio duration metadata is unavailable');
    }
    return duration;
  }
}
export async function concatAudioFiles(inputPaths, outputPath) {
  return AudioFileUtils.getInstance().concatAudioFilesInstance(inputPaths, outputPath);
}
export async function probeDuration(input, sampleRate, headers) {
  return AudioFileUtils.getInstance().probeDurationInstance(input, sampleRate, headers);
}
export async function getAudioDuration(input, fetchOptions) {
  return AudioFileUtils.getInstance().getAudioDurationInstance(input, fetchOptions);
}
//# sourceMappingURL=AudioFileUtils.js.map