@siteed/expo-audio-stream 1.0.2 → 1.0.5

package/build/workers/InlineFeaturesExtractor.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InlineFeaturesExtractor.web.js","sourceRoot":"","sources":["../../src/workers/InlineFeaturesExtractor.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6StC,CAAA","sourcesContent":["export const InlineFeaturesExtractor = `\n\n// Unique ID counter\nlet uniqueIdCounter = 0;\n\nself.onmessage = function (event) {\n  const {\n    channelData, // this is only the newly recorded data when live recording.\n    sampleRate,\n    pointsPerSecond,\n    algorithm,\n    bitDepth,\n    fullAudioDurationMs,\n    numberOfChannels,\n    features: _features,\n  } = event.data;\n\n  console.log(\"[AudioFeaturesExtractor] Worker received message\", event.data);\n  const features = _features || {};\n\n  const SILENCE_THRESHOLD = 0.01;\n  const MIN_SILENCE_DURATION = 1.5 * sampleRate; // 1.5 seconds of silence\n  const SPEECH_INERTIA_DURATION = 0.1 * sampleRate; // Speech inertia duration in samples\n  const RMS_THRESHOLD = 0.01;\n  const ZCR_THRESHOLD = 0.1;\n\n  // Placeholder functions for feature extraction\n  const extractMFCC = (segmentData, sampleRate) => {\n    // Implement MFCC extraction logic here\n    return [];\n  };\n\n  const extractSpectralCentroid = (segmentData, sampleRate) => {\n    const magnitudeSpectrum = segmentData.map((v) => v * v);\n    const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0);\n    if (sum === 0) return 0;\n\n    const weightedSum = magnitudeSpectrum.reduce(\n      (acc, value, index) => acc + index * value,\n      0,\n    );\n    return ((weightedSum / sum) * (sampleRate / 2)) / magnitudeSpectrum.length;\n  };\n\n  const extractSpectralFlatness = (segmentData) => {\n    const magnitudeSpectrum = segmentData.map((v) => Math.abs(v));\n    const geometricMean = Math.exp(\n      magnitudeSpectrum\n        .map((v) => Math.log(v + Number.MIN_VALUE))\n        .reduce((a, b) => a + b) / magnitudeSpectrum.length,\n    );\n    const arithmeticMean =\n      magnitudeSpectrum.reduce((a, b) => a + b) / magnitudeSpectrum.length;\n    return arithmeticMean === 0 ? 0 : geometricMean / arithmeticMean;\n  };\n\n  const extractSpectralRollOff = (segmentData, sampleRate) => {\n    const magnitudeSpectrum = segmentData.map((v) => Math.abs(v));\n    const totalEnergy = magnitudeSpectrum.reduce((a, b) => a + b, 0);\n    const rollOffThreshold = totalEnergy * 0.85;\n    let cumulativeEnergy = 0;\n\n    for (let i = 0; i < magnitudeSpectrum.length; i++) {\n      cumulativeEnergy += magnitudeSpectrum[i];\n      if (cumulativeEnergy >= rollOffThreshold) {\n        return (i / magnitudeSpectrum.length) * (sampleRate / 2);\n      }\n    }\n\n    return 0;\n  };\n\n  const extractSpectralBandwidth = (segmentData, sampleRate) => {\n    const centroid = extractSpectralCentroid(segmentData, sampleRate);\n    const magnitudeSpectrum = segmentData.map((v) => Math.abs(v));\n    const sum = magnitudeSpectrum.reduce((a, b) => a + b, 0);\n    if (sum === 0) return 0;\n\n    const weightedSum = magnitudeSpectrum.reduce(\n      (acc, value, index) => acc + value * Math.pow(index - centroid, 2),\n      0,\n    );\n    return Math.sqrt(weightedSum / sum);\n  };\n\n  const extractChromagram = (segmentData, sampleRate) => {\n    return []; // TODO implement\n  };\n\n  const extractHNR = (segmentData) => {\n    const frameSize = segmentData.length;\n    const autocorrelation = new Float32Array(frameSize);\n\n    // Compute the autocorrelation of the segment data\n    for (let i = 0; i < frameSize; i++) {\n      let sum = 0;\n      for (let j = 0; j < frameSize - i; j++) {\n        sum += segmentData[j] * segmentData[j + i];\n      }\n      autocorrelation[i] = sum;\n    }\n\n    // Find the maximum autocorrelation value (excluding the zero lag)\n    const maxAutocorrelation = Math.max(...autocorrelation.subarray(1));\n\n    // Compute the HNR\n    return autocorrelation[0] !== 0\n      ? 10 *\n          Math.log10(\n            maxAutocorrelation / (autocorrelation[0] - maxAutocorrelation),\n          )\n      : 0;\n  };\n\n  const extractWaveform = (\n    channelData, // Float32Array\n    sampleRate, // number\n    pointsPerSecond, // number\n    algorithm, // string\n  ) => {\n    const totalSamples = channelData.length;\n    const segmentDuration = totalSamples / sampleRate;\n    const totalPoints = Math.max(\n      Math.ceil(segmentDuration * pointsPerSecond),\n      1,\n    );\n    const pointInterval = Math.ceil(totalSamples / totalPoints);\n    const dataPoints = [];\n    let minAmplitude = Infinity;\n    let maxAmplitude = -Infinity;\n    let silenceStart = null;\n    let lastSpeechEnd = -Infinity;\n    let isSpeech = false;\n\n    const expectedPoints = segmentDuration * pointsPerSecond;\n    const samplesPerPoint = Math.ceil(channelData.length / expectedPoints);\n\n    for (let i = 0; i < expectedPoints; i++) {\n      const start = i * samplesPerPoint;\n      const end = Math.min(start + samplesPerPoint, totalSamples);\n\n      let sumSquares = 0;\n      let zeroCrossings = 0;\n      let prevValue = channelData[start];\n      let localMinAmplitude = Infinity;\n      let localMaxAmplitude = -Infinity;\n      let hasNonZeroValue = false;\n\n      // compute values for the segment\n      for (let j = start; j < end; j++) {\n        const value = channelData[j];\n        sumSquares += value * value;\n        if (j > start && value * prevValue < 0) {\n          zeroCrossings++;\n        }\n        prevValue = value;\n\n        const absValue = Math.abs(value);\n        localMinAmplitude = Math.min(localMinAmplitude, absValue);\n        localMaxAmplitude = Math.max(localMaxAmplitude, absValue);\n\n        if (absValue !== 0) {\n          hasNonZeroValue = true;\n        }\n      }\n\n      // Post-processing checks\n      if (!hasNonZeroValue) {\n        // All values are zero\n        localMinAmplitude = 0;\n        localMaxAmplitude = 0;\n      }\n\n      const rms = Math.sqrt(sumSquares / (end - start));\n      minAmplitude = Math.min(minAmplitude, rms);\n      maxAmplitude = Math.max(maxAmplitude, rms);\n\n      const energy = sumSquares;\n      const zcr = zeroCrossings / (end - start);\n\n      const silent = rms < SILENCE_THRESHOLD;\n      const dB = 20 * Math.log10(rms);\n\n      if (silent) {\n        if (silenceStart === null) {\n          silenceStart = start;\n        } else if (start - silenceStart > MIN_SILENCE_DURATION) {\n          // Silence detected for longer than the threshold, set amplitude to 0\n          localMaxAmplitude = 0;\n          localMinAmplitude = 0;\n          isSpeech = false;\n        }\n      } else {\n        silenceStart = null;\n        if (!isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION) {\n          isSpeech = true;\n        }\n        lastSpeechEnd = end;\n      }\n\n      const activeSpeech =\n        (rms > RMS_THRESHOLD && zcr > ZCR_THRESHOLD) ||\n        (isSpeech && start - lastSpeechEnd < SPEECH_INERTIA_DURATION);\n\n      if (activeSpeech) {\n        isSpeech = true;\n        lastSpeechEnd = end;\n      } else {\n        isSpeech = false;\n      }\n\n      const bytesPerSample = bitDepth / 8;\n      const startPosition = start * bytesPerSample * numberOfChannels; // Calculate start position in bytes\n      const endPosition = end * bytesPerSample * numberOfChannels; // Calculate end position in bytes\n\n      // Compute features\n      const segmentData = channelData.slice(start, end);\n      const mfcc = features.mfcc ? extractMFCC(segmentData, sampleRate) : [];\n      const spectralCentroid = features.spectralCentroid\n        ? extractSpectralCentroid(segmentData, sampleRate)\n        : 0;\n      const spectralFlatness = features.spectralFlatness\n        ? extractSpectralFlatness(segmentData)\n        : 0;\n      const spectralRollOff = features.spectralRollOff\n        ? extractSpectralRollOff(segmentData, sampleRate)\n        : 0;\n      const spectralBandwidth = features.spectralBandwidth\n        ? extractSpectralBandwidth(segmentData, sampleRate)\n        : 0;\n      const chromagram = features.chromagram\n        ? extractChromagram(segmentData, sampleRate)\n        : [];\n      const hnr = features.hnr ? extractHNR(segmentData) : 0;\n\n      const newData = {\n        id: uniqueIdCounter++, // Assign unique ID and increment the counter\n        amplitude: algorithm === \"peak\" ? localMaxAmplitude : rms,\n        activeSpeech,\n        dB,\n        silent,\n        features: {\n          energy,\n          rms,\n          minAmplitude: localMinAmplitude,\n          maxAmplitude: localMaxAmplitude,\n          zcr,\n          mfcc: [], // Placeholder for MFCC features\n          spectralCentroid, // Computed spectral centroid\n          spectralFlatness, // Computed spectral flatness\n          spectralRollOff, // Computed spectral roll-off\n          spectralBandwidth, // Computed spectral bandwidth\n          chromagram, // Computed chromagram\n          hnr, // Computed HNR\n        },\n        startTime: start / sampleRate,\n        endTime: end / sampleRate,\n        startPosition,\n        endPosition,\n        samples: end - start,\n        speaker: 0, // Assuming speaker detection is to be handled later\n      };\n\n      dataPoints.push(newData);\n    }\n\n    return {\n      pointsPerSecond,\n      durationMs: fullAudioDurationMs,\n      bitDepth,\n      samples: totalSamples,\n      numberOfChannels,\n      sampleRate,\n      dataPoints,\n      amplitudeRange: {\n        min: minAmplitude,\n        max: maxAmplitude,\n      },\n      speakerChanges: [], // Placeholder for future speaker detection logic\n    };\n  };\n\n  try {\n    const result = extractWaveform(\n      channelData,\n      sampleRate,\n      pointsPerSecond,\n      algorithm,\n    );\n    self.postMessage({\n      command: \"features\",\n      result,\n    });\n  } catch (error) {\n    console.error(\"[AudioFeaturesExtractor] Error in processing\", error);\n    self.postMessage({ error: error.message });\n  } finally {\n    // Do not close the worker so it can be re-used for subsequent messages\n    // self.close();\n  }\n};\n`\n"]}

package/build/workers/inlineAudioWebWorker.web.d.ts

@@ -0,0 +1,2 @@
+export declare const InlineAudioWebWorker = "\nconst DEFAULT_BIT_DEPTH = 32;\nconst DEFAULT_SAMPLE_RATE = 44100;\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n  constructor() {\n    super();\n    this.recordedBuffers = []; // Float32Array\n    this.newRecBuffer = []; // Float32Array\n    this.resampledBuffer = []; // Float32Array\n    this.exportIntervalSamples = 0;\n    this.samplesSinceLastExport = 0;\n    this.recordSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten\n    this.exportSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten\n    this.recordBitDepth = DEFAULT_BIT_DEPTH; // Default to 32-bit depth\n    this.exportBitDepth = DEFAULT_BIT_DEPTH; // To be overwritten\n    this.numberOfChannels = 1; // Default to 1 channel (mono)\n    this.isRecording = true;\n    this.port.onmessage = this.handleMessage.bind(this);\n  }\n\n  handleMessage(event) {\n    switch (event.data.command) {\n      case \"init\":\n        this.recordSampleRate = event.data.recordSampleRate;\n        this.exportSampleRate =\n          event.data.exportSampleRate || event.data.recordSampleRate;\n        this.exportIntervalSamples =\n          this.recordSampleRate * (event.data.interval / 1000);\n        if (event.data.numberOfChannels) {\n          this.numberOfChannels = event.data.numberOfChannels;\n        }\n        if (event.data.recordBitDepth) {\n          this.recordBitDepth = event.data.recordBitDepth;\n        }\n        this.exportBitDepth =\n          event.data.exportBitDepth || this.recordBitDepth || DEFAULT_BIT_DEPTH;\n        break;\n      case \"stop\":\n        this.isRecording = false;\n        this.getAllRecordedData()\n          .then((fullRecordedData) => {\n            this.port.postMessage({\n              command: \"recordedData\",\n              recordedData: fullRecordedData,\n              bitDepth: this.exportBitDepth,\n              sampleRate: this.exportSampleRate,\n            });\n            return fullRecordedData;\n          })\n          .catch((error) => {\n            console.error(\"Error extracting recorded data:\", error);\n          });\n        break;\n    }\n  }\n\n  process(inputs, outputs, parameters) {\n    if (!this.isRecording) return true;\n    const input = inputs[0];\n    if (input.length > 0) {\n      const newBuffer = new Float32Array(input[0]);\n      this.newRecBuffer.push(newBuffer);\n      this.recordedBuffers.push(newBuffer);\n      this.samplesSinceLastExport += newBuffer.length;\n\n      if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n        this.exportNewData();\n        this.samplesSinceLastExport = 0;\n      }\n    }\n    return true;\n  }\n\n  mergeBuffers(bufferArray, recLength) {\n    const result = new Float32Array(recLength);\n    let offset = 0;\n    for (let i = 0; i < bufferArray.length; i++) {\n      result.set(bufferArray[i], offset);\n      offset += bufferArray[i].length;\n    }\n    return result;\n  }\n\n  floatTo16BitPCM(input) {\n    const output = new Int16Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output[i] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n    console.debug(\n      \"Float to 16-bit PCM conversion complete. Output byte length:\",\n      output.byteLength,\n    );\n    return output;\n  }\n\n  floatTo32BitPCM(input) {\n    const output = new Int32Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff;\n    }\n    console.debug(\n      \"Float to 32-bit PCM conversion complete. Output byte length:\",\n      output.byteLength,\n    );\n    return output;\n  }\n\n  resample(samples, targetSampleRate) {\n    if (this.recordSampleRate === targetSampleRate) {\n      return samples;\n    }\n    const resampledBuffer = new Float32Array(\n      (samples.length * targetSampleRate) / this.recordSampleRate,\n    );\n    const ratio = this.recordSampleRate / targetSampleRate;\n    let offset = 0;\n    for (let i = 0; i < resampledBuffer.length; i++) {\n      const nextOffset = Math.floor((i + 1) * ratio);\n      let accum = 0;\n      let count = 0;\n      for (let j = offset; j < nextOffset && j < samples.length; j++) {\n        accum += samples[j];\n        count++;\n      }\n      resampledBuffer[i] = accum / count;\n      offset = nextOffset;\n    }\n    return resampledBuffer;\n  }\n\n  async resampleBuffer(buffer, targetSampleRate) {\n    if (typeof OfflineAudioContext === \"undefined\") {\n      return this.resample(buffer, targetSampleRate);\n    }\n\n    if (this.recordSampleRate === targetSampleRate) {\n      return buffer;\n    }\n    const offlineContext = new OfflineAudioContext(\n      this.numberOfChannels,\n      buffer.length,\n      this.recordSampleRate,\n    );\n    const sourceBuffer = offlineContext.createBuffer(\n      this.numberOfChannels,\n      buffer.length,\n      this.recordSampleRate,\n    );\n    sourceBuffer.copyToChannel(buffer, 0);\n\n    const bufferSource = offlineContext.createBufferSource();\n    bufferSource.buffer = sourceBuffer;\n    bufferSource.connect(offlineContext.destination);\n    bufferSource.start();\n\n    const renderedBuffer = await offlineContext.startRendering();\n\n    const resampledBuffer = new Float32Array(renderedBuffer.length);\n    renderedBuffer.copyFromChannel(resampledBuffer, 0);\n\n    return resampledBuffer;\n  }\n\n  async exportNewData() {\n    // Calculate the total length of the new recorded buffers\n    const length = this.newRecBuffer.reduce(\n      (acc, buffer) => acc + buffer.length,\n      0,\n    );\n\n    // Merge all new recorded buffers into a single buffer\n    const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length);\n\n    const resampledBuffer = await this.resampleBuffer(\n      mergedBuffer,\n      this.exportSampleRate,\n    );\n\n    let finalBuffer = resampledBuffer; // Float32Array\n    if (this.recordBitDepth !== this.exportBitDepth) {\n      if (this.exportBitDepth === 16) {\n        finalBuffer = this.floatTo16BitPCM(resampledBuffer);\n      } else if (this.exportBitDepth === 32) {\n        finalBuffer = this.floatTo32BitPCM(resampledBuffer);\n      }\n    }\n\n    const originalSize = mergedBuffer.byteLength;\n    const resampledSize = resampledBuffer.byteLength;\n    const finalSize = finalBuffer.byteLength;\n\n    // Clear the new recorded buffers after they have been processed\n    this.newRecBuffer.length = 0;\n\n    // Post the message to the main thread\n    // The first argument is the message data, containing the encoded WAV buffer\n    // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n    // to the main thread, avoiding the need to copy the buffer and improving performance\n    // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n    this.port.postMessage({\n      command: \"newData\",\n      recordedData: finalBuffer.buffer,\n      sampleRate: this.exportSampleRate,\n      bitDepth: this.exportBitDepth,\n    });\n  }\n\n  async getAllRecordedData() {\n    const length = this.recordedBuffers.reduce(\n      (acc, buffer) => acc + buffer.length,\n      0,\n    );\n    const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);\n    const resampledBuffer = await this.resampleBuffer(\n      mergedBuffer,\n      this.exportSampleRate,\n    );\n    // Convert to the desired bit depth if necessary\n    let finalBuffer = resampledBuffer;\n    if (this.recordBitDepth !== this.exportBitDepth) {\n      if (this.exportBitDepth === 16) {\n        finalBuffer = this.floatTo16BitPCM(resampledBuffer);\n      } else if (this.exportBitDepth === 32) {\n        finalBuffer = this.floatTo32BitPCM(resampledBuffer);\n      }\n    }\n\n    const originalSize = mergedBuffer.byteLength;\n    const resampledSize = resampledBuffer.byteLength;\n    const finalSize = finalBuffer.byteLength;\n\n    this.recordedBuffers.length = 0; // Clear the buffers after extraction\n\n    return finalBuffer.buffer;\n  }\n}\n\nregisterProcessor(\"recorder-processor\", RecorderProcessor);\n";
+//# sourceMappingURL=inlineAudioWebWorker.web.d.ts.map

package/build/workers/inlineAudioWebWorker.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.web.d.ts","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,4/PAiPhC,CAAA"}

package/build/workers/inlineAudioWebWorker.web.js

@@ -0,0 +1,243 @@
+export const InlineAudioWebWorker = `
+const DEFAULT_BIT_DEPTH = 32;
+const DEFAULT_SAMPLE_RATE = 44100;
+
+class RecorderProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.recordedBuffers = []; // Float32Array
+    this.newRecBuffer = []; // Float32Array
+    this.resampledBuffer = []; // Float32Array
+    this.exportIntervalSamples = 0;
+    this.samplesSinceLastExport = 0;
+    this.recordSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten
+    this.exportSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten
+    this.recordBitDepth = DEFAULT_BIT_DEPTH; // Default to 32-bit depth
+    this.exportBitDepth = DEFAULT_BIT_DEPTH; // To be overwritten
+    this.numberOfChannels = 1; // Default to 1 channel (mono)
+    this.isRecording = true;
+    this.port.onmessage = this.handleMessage.bind(this);
+  }
+
+  handleMessage(event) {
+    switch (event.data.command) {
+      case "init":
+        this.recordSampleRate = event.data.recordSampleRate;
+        this.exportSampleRate =
+          event.data.exportSampleRate || event.data.recordSampleRate;
+        this.exportIntervalSamples =
+          this.recordSampleRate * (event.data.interval / 1000);
+        if (event.data.numberOfChannels) {
+          this.numberOfChannels = event.data.numberOfChannels;
+        }
+        if (event.data.recordBitDepth) {
+          this.recordBitDepth = event.data.recordBitDepth;
+        }
+        this.exportBitDepth =
+          event.data.exportBitDepth || this.recordBitDepth || DEFAULT_BIT_DEPTH;
+        break;
+      case "stop":
+        this.isRecording = false;
+        this.getAllRecordedData()
+          .then((fullRecordedData) => {
+            this.port.postMessage({
+              command: "recordedData",
+              recordedData: fullRecordedData,
+              bitDepth: this.exportBitDepth,
+              sampleRate: this.exportSampleRate,
+            });
+            return fullRecordedData;
+          })
+          .catch((error) => {
+            console.error("Error extracting recorded data:", error);
+          });
+        break;
+    }
+  }
+
+  process(inputs, outputs, parameters) {
+    if (!this.isRecording) return true;
+    const input = inputs[0];
+    if (input.length > 0) {
+      const newBuffer = new Float32Array(input[0]);
+      this.newRecBuffer.push(newBuffer);
+      this.recordedBuffers.push(newBuffer);
+      this.samplesSinceLastExport += newBuffer.length;
+
+      if (this.samplesSinceLastExport >= this.exportIntervalSamples) {
+        this.exportNewData();
+        this.samplesSinceLastExport = 0;
+      }
+    }
+    return true;
+  }
+
+  mergeBuffers(bufferArray, recLength) {
+    const result = new Float32Array(recLength);
+    let offset = 0;
+    for (let i = 0; i < bufferArray.length; i++) {
+      result.set(bufferArray[i], offset);
+      offset += bufferArray[i].length;
+    }
+    return result;
+  }
+
+  floatTo16BitPCM(input) {
+    const output = new Int16Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      const s = Math.max(-1, Math.min(1, input[i]));
+      output[i] = s < 0 ? s * 0x8000 : s * 0x7fff;
+    }
+    console.debug(
+      "Float to 16-bit PCM conversion complete. Output byte length:",
+      output.byteLength,
+    );
+    return output;
+  }
+
+  floatTo32BitPCM(input) {
+    const output = new Int32Array(input.length);
+    for (let i = 0; i < input.length; i++) {
+      const s = Math.max(-1, Math.min(1, input[i]));
+      output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff;
+    }
+    console.debug(
+      "Float to 32-bit PCM conversion complete. Output byte length:",
+      output.byteLength,
+    );
+    return output;
+  }
+
+  resample(samples, targetSampleRate) {
+    if (this.recordSampleRate === targetSampleRate) {
+      return samples;
+    }
+    const resampledBuffer = new Float32Array(
+      (samples.length * targetSampleRate) / this.recordSampleRate,
+    );
+    const ratio = this.recordSampleRate / targetSampleRate;
+    let offset = 0;
+    for (let i = 0; i < resampledBuffer.length; i++) {
+      const nextOffset = Math.floor((i + 1) * ratio);
+      let accum = 0;
+      let count = 0;
+      for (let j = offset; j < nextOffset && j < samples.length; j++) {
+        accum += samples[j];
+        count++;
+      }
+      resampledBuffer[i] = accum / count;
+      offset = nextOffset;
+    }
+    return resampledBuffer;
+  }
+
+  async resampleBuffer(buffer, targetSampleRate) {
+    if (typeof OfflineAudioContext === "undefined") {
+      return this.resample(buffer, targetSampleRate);
+    }
+
+    if (this.recordSampleRate === targetSampleRate) {
+      return buffer;
+    }
+    const offlineContext = new OfflineAudioContext(
+      this.numberOfChannels,
+      buffer.length,
+      this.recordSampleRate,
+    );
+    const sourceBuffer = offlineContext.createBuffer(
+      this.numberOfChannels,
+      buffer.length,
+      this.recordSampleRate,
+    );
+    sourceBuffer.copyToChannel(buffer, 0);
+
+    const bufferSource = offlineContext.createBufferSource();
+    bufferSource.buffer = sourceBuffer;
+    bufferSource.connect(offlineContext.destination);
+    bufferSource.start();
+
+    const renderedBuffer = await offlineContext.startRendering();
+
+    const resampledBuffer = new Float32Array(renderedBuffer.length);
+    renderedBuffer.copyFromChannel(resampledBuffer, 0);
+
+    return resampledBuffer;
+  }
+
+  async exportNewData() {
+    // Calculate the total length of the new recorded buffers
+    const length = this.newRecBuffer.reduce(
+      (acc, buffer) => acc + buffer.length,
+      0,
+    );
+
+    // Merge all new recorded buffers into a single buffer
+    const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length);
+
+    const resampledBuffer = await this.resampleBuffer(
+      mergedBuffer,
+      this.exportSampleRate,
+    );
+
+    let finalBuffer = resampledBuffer; // Float32Array
+    if (this.recordBitDepth !== this.exportBitDepth) {
+      if (this.exportBitDepth === 16) {
+        finalBuffer = this.floatTo16BitPCM(resampledBuffer);
+      } else if (this.exportBitDepth === 32) {
+        finalBuffer = this.floatTo32BitPCM(resampledBuffer);
+      }
+    }
+
+    const originalSize = mergedBuffer.byteLength;
+    const resampledSize = resampledBuffer.byteLength;
+    const finalSize = finalBuffer.byteLength;
+
+    // Clear the new recorded buffers after they have been processed
+    this.newRecBuffer.length = 0;
+
+    // Post the message to the main thread
+    // The first argument is the message data, containing the encoded WAV buffer
+    // The second argument is the transfer list, which transfers ownership of the ArrayBuffer
+    // to the main thread, avoiding the need to copy the buffer and improving performance
+    // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);
+    this.port.postMessage({
+      command: "newData",
+      recordedData: finalBuffer.buffer,
+      sampleRate: this.exportSampleRate,
+      bitDepth: this.exportBitDepth,
+    });
+  }
+
+  async getAllRecordedData() {
+    const length = this.recordedBuffers.reduce(
+      (acc, buffer) => acc + buffer.length,
+      0,
+    );
+    const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);
+    const resampledBuffer = await this.resampleBuffer(
+      mergedBuffer,
+      this.exportSampleRate,
+    );
+    // Convert to the desired bit depth if necessary
+    let finalBuffer = resampledBuffer;
+    if (this.recordBitDepth !== this.exportBitDepth) {
+      if (this.exportBitDepth === 16) {
+        finalBuffer = this.floatTo16BitPCM(resampledBuffer);
+      } else if (this.exportBitDepth === 32) {
+        finalBuffer = this.floatTo32BitPCM(resampledBuffer);
+      }
+    }
+
+    const originalSize = mergedBuffer.byteLength;
+    const resampledSize = resampledBuffer.byteLength;
+    const finalSize = finalBuffer.byteLength;
+
+    this.recordedBuffers.length = 0; // Clear the buffers after extraction
+
+    return finalBuffer.buffer;
+  }
+}
+
+registerProcessor("recorder-processor", RecorderProcessor);
+`;
+//# sourceMappingURL=inlineAudioWebWorker.web.js.map

package/build/workers/inlineAudioWebWorker.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlineAudioWebWorker.web.js","sourceRoot":"","sources":["../../src/workers/inlineAudioWebWorker.web.tsx"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiPnC,CAAA","sourcesContent":["export const InlineAudioWebWorker = `\nconst DEFAULT_BIT_DEPTH = 32;\nconst DEFAULT_SAMPLE_RATE = 44100;\n\nclass RecorderProcessor extends AudioWorkletProcessor {\n  constructor() {\n    super();\n    this.recordedBuffers = []; // Float32Array\n    this.newRecBuffer = []; // Float32Array\n    this.resampledBuffer = []; // Float32Array\n    this.exportIntervalSamples = 0;\n    this.samplesSinceLastExport = 0;\n    this.recordSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten\n    this.exportSampleRate = DEFAULT_SAMPLE_RATE; // To be overwritten\n    this.recordBitDepth = DEFAULT_BIT_DEPTH; // Default to 32-bit depth\n    this.exportBitDepth = DEFAULT_BIT_DEPTH; // To be overwritten\n    this.numberOfChannels = 1; // Default to 1 channel (mono)\n    this.isRecording = true;\n    this.port.onmessage = this.handleMessage.bind(this);\n  }\n\n  handleMessage(event) {\n    switch (event.data.command) {\n      case \"init\":\n        this.recordSampleRate = event.data.recordSampleRate;\n        this.exportSampleRate =\n          event.data.exportSampleRate || event.data.recordSampleRate;\n        this.exportIntervalSamples =\n          this.recordSampleRate * (event.data.interval / 1000);\n        if (event.data.numberOfChannels) {\n          this.numberOfChannels = event.data.numberOfChannels;\n        }\n        if (event.data.recordBitDepth) {\n          this.recordBitDepth = event.data.recordBitDepth;\n        }\n        this.exportBitDepth =\n          event.data.exportBitDepth || this.recordBitDepth || DEFAULT_BIT_DEPTH;\n        break;\n      case \"stop\":\n        this.isRecording = false;\n        this.getAllRecordedData()\n          .then((fullRecordedData) => {\n            this.port.postMessage({\n              command: \"recordedData\",\n              recordedData: fullRecordedData,\n              bitDepth: this.exportBitDepth,\n              sampleRate: this.exportSampleRate,\n            });\n            return fullRecordedData;\n          })\n          .catch((error) => {\n            console.error(\"Error extracting recorded data:\", error);\n          });\n        break;\n    }\n  }\n\n  process(inputs, outputs, parameters) {\n    if (!this.isRecording) return true;\n    const input = inputs[0];\n    if (input.length > 0) {\n      const newBuffer = new Float32Array(input[0]);\n      this.newRecBuffer.push(newBuffer);\n      this.recordedBuffers.push(newBuffer);\n      this.samplesSinceLastExport += newBuffer.length;\n\n      if (this.samplesSinceLastExport >= this.exportIntervalSamples) {\n        this.exportNewData();\n        this.samplesSinceLastExport = 0;\n      }\n    }\n    return true;\n  }\n\n  mergeBuffers(bufferArray, recLength) {\n    const result = new Float32Array(recLength);\n    let offset = 0;\n    for (let i = 0; i < bufferArray.length; i++) {\n      result.set(bufferArray[i], offset);\n      offset += bufferArray[i].length;\n    }\n    return result;\n  }\n\n  floatTo16BitPCM(input) {\n    const output = new Int16Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output[i] = s < 0 ? s * 0x8000 : s * 0x7fff;\n    }\n    console.debug(\n      \"Float to 16-bit PCM conversion complete. Output byte length:\",\n      output.byteLength,\n    );\n    return output;\n  }\n\n  floatTo32BitPCM(input) {\n    const output = new Int32Array(input.length);\n    for (let i = 0; i < input.length; i++) {\n      const s = Math.max(-1, Math.min(1, input[i]));\n      output[i] = s < 0 ? s * 0x80000000 : s * 0x7fffffff;\n    }\n    console.debug(\n      \"Float to 32-bit PCM conversion complete. Output byte length:\",\n      output.byteLength,\n    );\n    return output;\n  }\n\n  resample(samples, targetSampleRate) {\n    if (this.recordSampleRate === targetSampleRate) {\n      return samples;\n    }\n    const resampledBuffer = new Float32Array(\n      (samples.length * targetSampleRate) / this.recordSampleRate,\n    );\n    const ratio = this.recordSampleRate / targetSampleRate;\n    let offset = 0;\n    for (let i = 0; i < resampledBuffer.length; i++) {\n      const nextOffset = Math.floor((i + 1) * ratio);\n      let accum = 0;\n      let count = 0;\n      for (let j = offset; j < nextOffset && j < samples.length; j++) {\n        accum += samples[j];\n        count++;\n      }\n      resampledBuffer[i] = accum / count;\n      offset = nextOffset;\n    }\n    return resampledBuffer;\n  }\n\n  async resampleBuffer(buffer, targetSampleRate) {\n    if (typeof OfflineAudioContext === \"undefined\") {\n      return this.resample(buffer, targetSampleRate);\n    }\n\n    if (this.recordSampleRate === targetSampleRate) {\n      return buffer;\n    }\n    const offlineContext = new OfflineAudioContext(\n      this.numberOfChannels,\n      buffer.length,\n      this.recordSampleRate,\n    );\n    const sourceBuffer = offlineContext.createBuffer(\n      this.numberOfChannels,\n      buffer.length,\n      this.recordSampleRate,\n    );\n    sourceBuffer.copyToChannel(buffer, 0);\n\n    const bufferSource = offlineContext.createBufferSource();\n    bufferSource.buffer = sourceBuffer;\n    bufferSource.connect(offlineContext.destination);\n    bufferSource.start();\n\n    const renderedBuffer = await offlineContext.startRendering();\n\n    const resampledBuffer = new Float32Array(renderedBuffer.length);\n    renderedBuffer.copyFromChannel(resampledBuffer, 0);\n\n    return resampledBuffer;\n  }\n\n  async exportNewData() {\n    // Calculate the total length of the new recorded buffers\n    const length = this.newRecBuffer.reduce(\n      (acc, buffer) => acc + buffer.length,\n      0,\n    );\n\n    // Merge all new recorded buffers into a single buffer\n    const mergedBuffer = this.mergeBuffers(this.newRecBuffer, length);\n\n    const resampledBuffer = await this.resampleBuffer(\n      mergedBuffer,\n      this.exportSampleRate,\n    );\n\n    let finalBuffer = resampledBuffer; // Float32Array\n    if (this.recordBitDepth !== this.exportBitDepth) {\n      if (this.exportBitDepth === 16) {\n        finalBuffer = this.floatTo16BitPCM(resampledBuffer);\n      } else if (this.exportBitDepth === 32) {\n        finalBuffer = this.floatTo32BitPCM(resampledBuffer);\n      }\n    }\n\n    const originalSize = mergedBuffer.byteLength;\n    const resampledSize = resampledBuffer.byteLength;\n    const finalSize = finalBuffer.byteLength;\n\n    // Clear the new recorded buffers after they have been processed\n    this.newRecBuffer.length = 0;\n\n    // Post the message to the main thread\n    // The first argument is the message data, containing the encoded WAV buffer\n    // The second argument is the transfer list, which transfers ownership of the ArrayBuffer\n    // to the main thread, avoiding the need to copy the buffer and improving performance\n    // this.port.postMessage({ recordedData: encodedWav.buffer, sampleRate: this.recordSampleRate }, [encodedWav.buffer]);\n    this.port.postMessage({\n      command: \"newData\",\n      recordedData: finalBuffer.buffer,\n      sampleRate: this.exportSampleRate,\n      bitDepth: this.exportBitDepth,\n    });\n  }\n\n  async getAllRecordedData() {\n    const length = this.recordedBuffers.reduce(\n      (acc, buffer) => acc + buffer.length,\n      0,\n    );\n    const mergedBuffer = this.mergeBuffers(this.recordedBuffers, length);\n    const resampledBuffer = await this.resampleBuffer(\n      mergedBuffer,\n      this.exportSampleRate,\n    );\n    // Convert to the desired bit depth if necessary\n    let finalBuffer = resampledBuffer;\n    if (this.recordBitDepth !== this.exportBitDepth) {\n      if (this.exportBitDepth === 16) {\n        finalBuffer = this.floatTo16BitPCM(resampledBuffer);\n      } else if (this.exportBitDepth === 32) {\n        finalBuffer = this.floatTo32BitPCM(resampledBuffer);\n      }\n    }\n\n    const originalSize = mergedBuffer.byteLength;\n    const resampledSize = resampledBuffer.byteLength;\n    const finalSize = finalBuffer.byteLength;\n\n    this.recordedBuffers.length = 0; // Clear the buffers after extraction\n\n    return finalBuffer.buffer;\n  }\n}\n\nregisterProcessor(\"recorder-processor\", RecorderProcessor);\n`\n"]}

package/expo-module.config.json

@@ -1,18 +1,9 @@
 {
-  "platforms": [
-    "ios",
-    "tvos",
-    "android",
-    "web"
-  ],
-  "ios": {
-    "modules": [
-      "ExpoAudioStreamModule"
-    ]
-  },
-  "android": {
-    "modules": [
-      "net.siteed.audiostream.ExpoAudioStreamModule"
-    ]
-  }
-}
+    "platforms": ["ios", "tvos", "android", "web"],
+    "ios": {
+        "modules": ["ExpoAudioStreamModule"]
+    },
+    "android": {
+        "modules": ["net.siteed.audiostream.ExpoAudioStreamModule"]
+    }
+}

package/ios/AudioStreamManager.swift

@@ -32,6 +32,8 @@ class AudioStreamManager: NSObject {
     internal var recordingFileURL: URL?
     private var audioProcessor: AudioProcessor?
     private var startTime: Date?
+    private var pauseStartTime: Date?
+
     internal var lastEmissionTime: Date?
     internal var lastEmittedSize: Int64 = 0
     private var emissionInterval: TimeInterval = 1.0 // Default to 1 second
@@ -144,8 +146,8 @@ class AudioStreamManager: NSObject {
         
         // Calculate the duration in seconds
         let durationInSeconds = Double(totalDataSize) / (sampleRate * channels * (bitDepth / 8))
-        let durationInMilliseconds = Int(durationInSeconds * 1000)
-        
+        let durationInMilliseconds = Int(durationInSeconds * 1000) - Int(pausedDuration * 1000)
+
         return [
             "durationMs": durationInMilliseconds,
             "isRecording": isRecording,
@@ -192,6 +194,8 @@ class AudioStreamManager: NSObject {
         lastEmissionTime = Date()
         accumulatedData.removeAll()
         totalDataSize = 0
+        pausedDuration = 0
+        isPaused = false
         
         let session = AVAudioSession.sharedInstance()
         do {
@@ -283,6 +287,39 @@ class AudioStreamManager: NSObject {
         }
     }
     
+    /// Pauses the current audio recording.
+    func pauseRecording() {
+        guard isRecording && !isPaused else {
+            Logger.debug("Recording is not in progress or already paused.")
+            return
+        }
+        
+        audioEngine.pause()
+        isPaused = true
+        pauseStartTime = Date()
+        
+        Logger.debug("Recording paused.")
+    }
+    
+    /// Resumes the current audio recording.
+    func resumeRecording() {
+        guard isRecording && isPaused else {
+            Logger.debug("Recording is not in progress or not paused.")
+            return
+        }
+        
+        audioEngine.prepare()
+        do {
+            try audioEngine.start()
+            isPaused = false
+            if let pauseStartTime = pauseStartTime {
+                pausedDuration += Int(Date().timeIntervalSince(pauseStartTime))
+            }
+            Logger.debug("Recording resumed.")
+        } catch {
+            Logger.debug("Error: Failed to resume recording: \(error.localizedDescription)")
+        }
+    }
     
     /// Describes the format of the given audio format.
     /// - Parameter format: The AVAudioFormat object to describe.
@@ -342,6 +379,7 @@ class AudioStreamManager: NSObject {
             
             let result = RecordingResult(
                 fileUri: fileURL.absoluteString,
+                filename: fileURL.lastPathComponent,
                 mimeType: mimeType,
                 duration: duration,
                 size: fileSize,

package/ios/ExpoAudioStreamModule.swift

@@ -178,6 +178,16 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
             return self.streamManager.getStatus()
         }
         
+        /// Pauses audio recording.
+        Function("pauseRecording") {
+            self.streamManager.pauseRecording()
+        }
+        
+        /// Resumes audio recording.
+        Function("resumeRecording") {
+            self.streamManager.resumeRecording()
+        }
+        
         /// Asynchronously stops audio recording and retrieves the recording result.
         ///
         /// - Parameters:
@@ -187,6 +197,7 @@ public class ExpoAudioStreamModule: Module, AudioStreamManagerDelegate {
                 // Convert RecordingResult to a dictionary
                 let resultDict: [String: Any] = [
                     "fileUri": recordingResult.fileUri,
+                    "filename": recordingResult.filename,
                     "durationMs": recordingResult.duration,
                     "size": recordingResult.size,
                     "channels": recordingResult.channels,

package/ios/RecordingResult.swift

@@ -2,6 +2,7 @@
 
 struct RecordingResult {
     var fileUri: String
+    var filename: String
     var mimeType: String
     var duration: Int64
     var size: Int64

package/package.json

@@ -1,66 +1,74 @@
 {
-  "name": "@siteed/expo-audio-stream",
-  "version": "1.0.2",
-  "description": "stream audio crossplatform",
-  "license": "MIT",
-  "main": "build/index.js",
-  "types": "build/index.d.ts",
-  "author": "Arthur Breton <abreton@siteed.net> (https://github.com/deeeed)",
-  "homepage": "https://github.com/deeeed/expo-audio-stream#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/deeeed/expo-audio-stream.git",
-    "directory": "packages/expo-audio-stream"
-  },
-  "bugs": {
-    "url": "https://github.com/deeeed/expo-audio-stream/issues"
-  },
-  "keywords": [
-    "react-native",
-    "expo",
-    "expo-audio-stream",
-    "ExpoAudioStream"
-  ],
-  "scripts": {
-    "build": "expo-module build",
-    "clean": "expo-module clean",
-    "lint": "expo-module lint",
-    "test": "expo-module test",
-    "prepare": "expo-module prepare",
-    "prepublishOnly": "expo-module prepublishOnly",
-    "expo-module": "expo-module",
-    "open:ios": "open -a \"Xcode\" ../../apps/playground/ios",
-    "open:android": "open -a \"Android Studio\" ../../apps/playground/android"
-  },
-  "dependencies": {
-    "react-native-quick-base64": "^2.1.2"
-  },
-  "devDependencies": {
-    "@expo/config-plugins": "^7.9.1",
-    "@types/debug": "^4.1.12",
-    "@types/node": "^20.12.7",
-    "@types/react": "^18.0.25",
-    "@typescript-eslint/eslint-plugin": "^7.7.0",
-    "@typescript-eslint/parser": "^7.7.0",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-config-universe": "^12.0.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "eslint-plugin-promise": "^6.1.1",
-    "eslint-plugin-react": "^7.34.1",
-    "expo-module-scripts": "^3.5.2",
-    "expo-modules-core": "^1.12.19",
-    "prettier": "^3.2.5",
-    "react-native": "^0.74.3"
-  },
-  "peerDependencies": {
-    "expo": "*",
-    "react": "*",
-    "react-native": "*"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  }
+    "name": "@siteed/expo-audio-stream",
+    "version": "1.0.5",
+    "description": "stream audio crossplatform",
+    "license": "MIT",
+    "main": "build/index.js",
+    "types": "build/index.d.ts",
+    "author": "Arthur Breton <abreton@siteed.net> (https://github.com/deeeed)",
+    "homepage": "https://github.com/deeeed/expo-audio-stream#readme",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/deeeed/expo-audio-stream.git",
+        "directory": "packages/expo-audio-stream"
+    },
+    "bugs": {
+        "url": "https://github.com/deeeed/expo-audio-stream/issues"
+    },
+    "keywords": [
+        "react-native",
+        "expo",
+        "expo-audio-stream",
+        "ExpoAudioStream"
+    ],
+    "scripts": {
+        "build": "expo-module build",
+        "clean": "expo-module clean",
+        "lint": "expo-module lint",
+        "test": "expo-module test",
+        "typecheck": "tsc --noEmit",
+        "prepare": "expo-module prepare",
+        "prepublishOnly": "expo-module prepublishOnly",
+        "expo-module": "expo-module",
+        "open:ios": "open -a \"Xcode\" ../../apps/playground/ios",
+        "open:android": "open -a \"Android Studio\" ../../apps/playground/android",
+        "size": "bundle-size && size-limit",
+        "release": "./publish.sh"
+    },
+    "devDependencies": {
+        "@expo/config-plugins": "^7.9.1",
+        "@size-limit/preset-big-lib": "^11.1.4",
+        "@types/jest": "^29.5.12",
+        "@types/node": "^20.12.7",
+        "@types/react": "^18.0.25",
+        "@typescript-eslint/eslint-plugin": "^7.7.0",
+        "@typescript-eslint/parser": "^7.7.0",
+        "bundle-size": "^1.1.5",
+        "eslint": "^8.56.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-config-universe": "^12.0.0",
+        "eslint-plugin-import": "^2.29.1",
+        "eslint-plugin-prettier": "^5.1.3",
+        "eslint-plugin-promise": "^6.1.1",
+        "eslint-plugin-react": "^7.34.1",
+        "expo-module-scripts": "^3.5.2",
+        "expo-modules-core": "^1.12.19",
+        "jest": "^29.7.0",
+        "prettier": "^3.2.5",
+        "react-native": "^0.74.3",
+        "size-limit": "^11.1.4",
+        "typescript": "^5.5.4"
+    },
+    "peerDependencies": {
+        "expo": "*",
+        "react": "*",
+        "react-native": "*"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    },
+    "dependencies": {
+        "@siteed/react-native-logger": "^0.9.2"
+    }
 }

package/plugin/build/index.d.ts

@@ -1,4 +1,4 @@
-import { ConfigPlugin } from "@expo/config-plugins";
+import { ConfigPlugin } from '@expo/config-plugins';
 declare const withRecordingPermission: ConfigPlugin<{
     microphonePermission: string;
 }>;

package/plugin/build/index.js

@@ -1,26 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const config_plugins_1 = require("@expo/config-plugins");
-const MICROPHONE_USAGE = "Allow $(PRODUCT_NAME) to access your microphone";
+const MICROPHONE_USAGE = 'Allow $(PRODUCT_NAME) to access your microphone';
 const withRecordingPermission = (config, existingPerms) => {
     if (!existingPerms) {
-        console.warn("No previous permissions provided");
+        console.warn('No previous permissions provided');
     }
     config = (0, config_plugins_1.withInfoPlist)(config, (config) => {
-        config.modResults["NSMicrophoneUsageDescription"] = MICROPHONE_USAGE;
+        config.modResults['NSMicrophoneUsageDescription'] = MICROPHONE_USAGE;
         // Add audio to UIBackgroundModes to allow background audio recording
         const existingBackgroundModes = config.modResults.UIBackgroundModes || [];
-        if (!existingBackgroundModes.includes("audio")) {
-            existingBackgroundModes.push("audio");
+        if (!existingBackgroundModes.includes('audio')) {
+            existingBackgroundModes.push('audio');
         }
         config.modResults.UIBackgroundModes = existingBackgroundModes;
         return config;
     });
     config = (0, config_plugins_1.withAndroidManifest)(config, (config) => {
         const mainApplication = config_plugins_1.AndroidConfig.Manifest.getMainApplicationOrThrow(config.modResults);
-        config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(mainApplication, "android.permission.RECORD_AUDIO", MICROPHONE_USAGE);
+        config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(mainApplication, 'android.permission.RECORD_AUDIO', MICROPHONE_USAGE);
         // Add FOREGROUND_SERVICE permission for handling background recording
-        config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(mainApplication, "android.permission.FOREGROUND_SERVICE", "This apps needs access to the foreground service to record audio in the background");
+        config_plugins_1.AndroidConfig.Manifest.addMetaDataItemToMainApplication(mainApplication, 'android.permission.FOREGROUND_SERVICE', 'This apps needs access to the foreground service to record audio in the background');
         return config;
     });
     return config;