stream-chat-react/dist/es/audioProcessing.766ca76c.mjs

React components to create chat conversations or livestream style chat

import { useCallback } from "react";
//#region src/components/ReactFileUtilities/utils.ts
var useHandleFileChangeWrapper = (resetOnChange = false, handler) => useCallback(({ currentTarget }) => {
	const { files } = currentTarget;
	if (!files) return;
	try {
		handler?.(Array.from(files));
	} catch (error) {
		console.error(error);
	}
	if (resetOnChange) currentTarget.value = "";
}, [handler, resetOnChange]);
async function dataTransferItemsToFiles(items) {
	if (!items || !items.length) return [];
	const fileLikes = getFileLikes(items);
	if (fileLikes.length) return fileLikes;
	const blobPromises = [];
	for (const item of items) if (item.type === "text/html") blobPromises.push(new Promise((accept) => {
		item.getAsString(async (s) => {
			const imagePromises = extractImageSources(s).map((src) => getImageSource(fileLikes, src));
			await Promise.all(imagePromises);
			accept();
		});
	}));
	await Promise.all(blobPromises);
	return fileLikes;
}
function getFileLikes(items) {
	const fileLikes = [];
	for (const item of items) if (item.kind === "file") {
		const file = item.getAsFile();
		if (file) fileLikes.push(file);
	}
	return fileLikes;
}
async function getImageSource(fileLikes, src) {
	let res;
	try {
		res = await fetch(src);
	} catch (e) {
		return;
	}
	const contentType = res.headers.get("Content-type") || "application/octet-stream";
	const buf = await res.arrayBuffer();
	const blob = new Blob([buf], { type: contentType });
	fileLikes.push(blob);
}
var extractImageSources = (s) => {
	const imageTags = new DOMParser().parseFromString(s, "text/html").getElementsByTagName("img");
	return Array.from(imageTags, (tag) => tag.src).filter((tag) => tag);
};
var createFileFromBlobs = ({ blobsArray, fileName, mimeType }) => {
	const concatenatedBlob = new Blob(blobsArray, { type: mimeType });
	return new File([concatenatedBlob], fileName, { type: concatenatedBlob.type });
};
var getExtensionFromMimeType = (mimeType) => {
	const match = mimeType.match(/\/([^/;]+)/);
	return match && match[1];
};
var getRecordedMediaTypeFromMimeType = (mimeType) => {
	const match = mimeType.match(/^(audio|video)\/.*$/);
	return match && match[1];
};
var readFileAsArrayBuffer = (file) => new Promise((resolve, reject) => {
	const fileReader = new FileReader();
	fileReader.onload = () => {
		resolve(fileReader.result);
	};
	fileReader.onerror = () => {
		reject(fileReader.error);
	};
	fileReader.readAsArrayBuffer(file);
});
//#endregion
//#region src/components/MediaRecorder/transcode/audioProcessing.ts
/**
* In the context of resampling audio data, AudioContext is used to decode the input audio file into an AudioBuffer,
* which is a fundamental data structure representing audio data.
* @param file
*/
var toAudioBuffer = async (file) => {
	const audioCtx = new AudioContext();
	const arrayBuffer = await readFileAsArrayBuffer(file);
	const decodedData = await audioCtx.decodeAudioData(arrayBuffer);
	if (audioCtx.state !== "closed") await audioCtx.close();
	return decodedData;
};
/**
* OfflineAudioContext is a specialized type of AudioContext that does not render audio in real-time and is used for offline audio processing tasks.
* It allows performing audio processing and rendering without actually playing the audio through speakers or outputting it to a destination.
* In the context of resampling audio data, OfflineAudioContext is used to resample the decoded AudioBuffer from a file to the desired sample rate.
* It provides more flexibility and control over audio processing, as it can operate at different sample rates and durations compared to real-time audio contexts.
* @param audioBuffer
* @param sampleRate
*/
var renderAudio = async (audioBuffer, sampleRate) => {
	const offlineAudioCtx = new OfflineAudioContext(audioBuffer.numberOfChannels, audioBuffer.duration * sampleRate, sampleRate);
	const source = offlineAudioCtx.createBufferSource();
	source.buffer = audioBuffer;
	source.connect(offlineAudioCtx.destination);
	source.start();
	return await offlineAudioCtx.startRendering();
};
//#endregion
export { getExtensionFromMimeType as a, dataTransferItemsToFiles as i, toAudioBuffer as n, getRecordedMediaTypeFromMimeType as o, createFileFromBlobs as r, useHandleFileChangeWrapper as s, renderAudio as t };

//# sourceMappingURL=audioProcessing.766ca76c.mjs.map