react-native-audio-api/lib/commonjs/core/AudioFileUtils.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.concatAudioFiles = concatAudioFiles;
exports.getAudioDuration = getAudioDuration;
exports.probeDuration = probeDuration;
var _errors = require("../errors");
var _utils = require("../utils");
var _paths = require("../utils/paths");
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 _errors.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 _errors.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 ((0, _paths.isBase64Source)(input)) {
        throw new _errors.AudioApiError('Base64 source decoding is not currently supported, to decode raw PCM base64 strings use decodePCMInBase64 method.');
      }
      if ((0, _paths.isDataBlobString)(input)) {
        throw new _errors.AudioApiError('Data Blob string decoding is not currently supported.');
      }
      const headers = (0, _utils.headersFromRequestInit)(fetchOptions);
      const source = (0, _paths.isRemoteSource)(input) ? input : (0, _paths.resolveLocalFilePath)(input);
      duration = await this.probeDurationInstance(source, 0, headers);
    }
    if (duration === null) {
      throw new _errors.AudioApiError('Audio duration metadata is unavailable');
    }
    return duration;
  }
}
async function concatAudioFiles(inputPaths, outputPath) {
  return AudioFileUtils.getInstance().concatAudioFilesInstance(inputPaths, outputPath);
}
async function probeDuration(input, sampleRate, headers) {
  return AudioFileUtils.getInstance().probeDurationInstance(input, sampleRate, headers);
}
async function getAudioDuration(input, fetchOptions) {
  return AudioFileUtils.getInstance().getAudioDurationInstance(input, fetchOptions);
}
//# sourceMappingURL=AudioFileUtils.js.map