stream-chat-react 11.20.0 → 12.0.0-rc.1

package/dist/components/MediaRecorder/observable/BehaviorSubject.js

@@ -1,34 +1,25 @@
-import { __extends } from "tslib";
 import { Subject } from './Subject';
 import { createObserver } from './Observer';
-var BehaviorSubject = /** @class */ (function (_super) {
-    __extends(BehaviorSubject, _super);
-    function BehaviorSubject(_value) {
-        var _this = _super.call(this) || this;
-        _this._value = _value;
-        return _this;
+export class BehaviorSubject extends Subject {
+    constructor(_value) {
+        super();
+        this._value = _value;
     }
-    Object.defineProperty(BehaviorSubject.prototype, "value", {
-        get: function () {
-            var _a = this, _value = _a._value, thrownError = _a.thrownError;
-            if (thrownError) {
-                throw thrownError;
-            }
-            return _value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BehaviorSubject.prototype.subscribe = function (observerOrNext) {
-        var observer = createObserver(observerOrNext);
-        var subscription = _super.prototype.subscribe.call(this, observerOrNext);
+    get value() {
+        const { _value, thrownError } = this;
+        if (thrownError) {
+            throw thrownError;
+        }
+        return _value;
+    }
+    subscribe(observerOrNext) {
+        const observer = createObserver(observerOrNext);
+        const subscription = super.subscribe(observerOrNext);
         if (!subscription.closed)
             observer.next(this._value);
         return subscription;
-    };
-    BehaviorSubject.prototype.next = function (value) {
-        _super.prototype.next.call(this, (this._value = value));
-    };
-    return BehaviorSubject;
-}(Subject));
-export { BehaviorSubject };
+    }
+    next(value) {
+        super.next((this._value = value));
+    }
+}

package/dist/components/MediaRecorder/observable/Observable.d.ts

@@ -15,4 +15,3 @@ export declare class Observable<T> implements Subscribable<T> {
     subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
 }
 export {};
-//# sourceMappingURL=Observable.d.ts.map

package/dist/components/MediaRecorder/observable/Observable.js

@@ -1,29 +1,21 @@
 import { createObserver } from './Observer';
 import { Subscription } from './Subscription';
-var Observable = /** @class */ (function () {
-    function Observable(producer) {
+export class Observable {
+    constructor(producer) {
         this._closed = false;
         if (producer)
             this._producer = producer;
     }
-    Object.defineProperty(Observable.prototype, "closed", {
-        get: function () {
-            return this._closed;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Observable.prototype.subscribe = function (observerOrNext) {
-        var _this = this;
-        var _a;
-        var observer = createObserver(observerOrNext);
+    get closed() {
+        return this._closed;
+    }
+    subscribe(observerOrNext) {
+        const observer = createObserver(observerOrNext);
         if (!this.closed) {
-            (_a = this._producer) === null || _a === void 0 ? void 0 : _a.call(this, observer);
+            this._producer?.(observer);
         }
-        return new Subscription(function () {
-            _this._closed = true;
+        return new Subscription(() => {
+            this._closed = true;
         });
-    };
-    return Observable;
-}());
-export { Observable };
+    }
+}

package/dist/components/MediaRecorder/observable/Observer.d.ts

@@ -7,4 +7,3 @@ export type Observer<T> = {
 export type ObserverOrNext<T> = Next<T> | Observer<T>;
 export declare function createObserver<T>(observerOrNext: ObserverOrNext<T>): Observer<T>;
 export {};
-//# sourceMappingURL=Observer.d.ts.map

package/dist/components/MediaRecorder/observable/Subject.d.ts

@@ -13,4 +13,3 @@ export declare class Subject<T> extends Observable<T> implements SubscriptionLik
     subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
     unsubscribe(): void;
 }
-//# sourceMappingURL=Subject.d.ts.map

package/dist/components/MediaRecorder/observable/Subject.js

@@ -1,70 +1,58 @@
-import { __extends } from "tslib";
 import { Observable } from './Observable';
 import { Subscription } from './Subscription';
 import { createObserver } from './Observer';
-var Subject = /** @class */ (function (_super) {
-    __extends(Subject, _super);
-    function Subject() {
-        var _this = _super.call(this) || this;
-        _this._observers = new Map();
-        _this._observerCounter = 0;
-        return _this;
+export class Subject extends Observable {
+    constructor() {
+        super();
+        this._observers = new Map();
+        this._observerCounter = 0;
     }
-    Object.defineProperty(Subject.prototype, "observers", {
-        get: function () {
-            return Array.from(this._observers.values());
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Subject.prototype.next = function (value) {
+    get observers() {
+        return Array.from(this._observers.values());
+    }
+    next(value) {
         if (this.closed)
             return;
-        var observers = this.observers;
-        for (var i = 0; i < observers.length; i++) {
+        const observers = this.observers;
+        for (let i = 0; i < observers.length; i++) {
             observers[i].next(value);
         }
-    };
-    Subject.prototype.error = function (err) {
-        var _a, _b;
+    }
+    error(err) {
         if (this.closed)
             return;
         this.thrownError = err;
-        var observers = this.observers;
-        for (var i = 0; i < observers.length; i++) {
-            (_b = (_a = observers[i]).error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+        const { observers } = this;
+        for (let i = 0; i < observers.length; i++) {
+            observers[i].error?.(err);
         }
         this._observers.clear();
-    };
-    Subject.prototype.complete = function () {
-        var _a, _b;
+    }
+    complete() {
         if (this.closed)
             return;
         this._closed = true;
-        var observers = this.observers;
-        for (var i = 0; i < observers.length; i++) {
-            (_b = (_a = observers[i]).complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+        const { observers } = this;
+        for (let i = 0; i < observers.length; i++) {
+            observers[i].complete?.();
         }
         this._observers.clear();
-    };
-    Subject.prototype.subscribe = function (observerOrNext) {
-        var _this = this;
-        var observer = createObserver(observerOrNext);
+    }
+    subscribe(observerOrNext) {
+        const observer = createObserver(observerOrNext);
         if (this.thrownError || this.closed) {
-            var subscription = new Subscription();
+            const subscription = new Subscription();
             subscription.closed = true;
             return subscription;
         }
-        var observerId = this._observerCounter++;
+        const observerId = this._observerCounter++;
         this._observers.set(observerId, observer);
-        return new Subscription(function () {
-            _this._observers.delete(observerId);
+        return new Subscription(() => {
+            this._observers.delete(observerId);
         });
-    };
-    Subject.prototype.unsubscribe = function () {
+    }
+    unsubscribe() {
         this._closed = true;
         this._observers.clear();
-    };
-    return Subject;
-}(Observable));
-export { Subject };
+    }
+}

package/dist/components/MediaRecorder/observable/Subscription.d.ts

@@ -8,4 +8,3 @@ export declare class Subscription implements SubscriptionLike {
     constructor(unsubscribe?: () => void);
     unsubscribe(): void;
 }
-//# sourceMappingURL=Subscription.d.ts.map

package/dist/components/MediaRecorder/observable/Subscription.js

@@ -1,13 +1,10 @@
-var Subscription = /** @class */ (function () {
-    function Subscription(unsubscribe) {
+export class Subscription {
+    constructor(unsubscribe) {
         this.closed = false;
         this._unsubscribe = unsubscribe;
     }
-    Subscription.prototype.unsubscribe = function () {
-        var _a;
+    unsubscribe() {
         this.closed = true;
-        (_a = this._unsubscribe) === null || _a === void 0 ? void 0 : _a.call(this);
-    };
-    return Subscription;
-}());
-export { Subscription };
+        this._unsubscribe?.();
+    }
+}

package/dist/components/MediaRecorder/observable/index.d.ts

@@ -3,4 +3,3 @@ export * from './Observable';
 export * from './Observer';
 export * from './Subject';
 export * from './Subscription';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/MediaRecorder/transcode/audioProcessing.d.ts

@@ -13,4 +13,3 @@ export declare const toAudioBuffer: (file: File) => Promise<AudioBuffer>;
  * @param sampleRate
  */
 export declare const renderAudio: (audioBuffer: AudioBuffer, sampleRate: number) => Promise<AudioBuffer>;
-//# sourceMappingURL=audioProcessing.d.ts.map

package/dist/components/MediaRecorder/transcode/audioProcessing.js

@@ -1,31 +1,17 @@
-import { __awaiter, __generator } from "tslib";
 import { readFileAsArrayBuffer } from '../../ReactFileUtilities';
 /**
  * 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
  */
-export var toAudioBuffer = function (file) { return __awaiter(void 0, void 0, void 0, function () {
-    var audioCtx, arrayBuffer, decodedData;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                audioCtx = new AudioContext();
-                return [4 /*yield*/, readFileAsArrayBuffer(file)];
-            case 1:
-                arrayBuffer = _a.sent();
-                return [4 /*yield*/, audioCtx.decodeAudioData(arrayBuffer)];
-            case 2:
-                decodedData = _a.sent();
-                if (!(audioCtx.state !== 'closed')) return [3 /*break*/, 4];
-                return [4 /*yield*/, audioCtx.close()];
-            case 3:
-                _a.sent();
-                _a.label = 4;
-            case 4: return [2 /*return*/, decodedData];
-        }
-    });
-}); };
+export const 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.
@@ -34,18 +20,11 @@ export var toAudioBuffer = function (file) { return __awaiter(void 0, void 0, vo
  * @param audioBuffer
  * @param sampleRate
  */
-export var renderAudio = function (audioBuffer, sampleRate) { return __awaiter(void 0, void 0, void 0, function () {
-    var offlineAudioCtx, source;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                offlineAudioCtx = new OfflineAudioContext(audioBuffer.numberOfChannels, audioBuffer.duration * sampleRate, sampleRate);
-                source = offlineAudioCtx.createBufferSource();
-                source.buffer = audioBuffer;
-                source.connect(offlineAudioCtx.destination);
-                source.start();
-                return [4 /*yield*/, offlineAudioCtx.startRendering()];
-            case 1: return [2 /*return*/, _a.sent()];
-        }
-    });
-}); };
+export const 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();
+};

package/dist/components/MediaRecorder/transcode/index.d.ts

@@ -5,4 +5,3 @@ type TranscodeParams = {
 };
 export declare const transcode: ({ blob, sampleRate, targetMimeType }: TranscodeParams) => Promise<Blob>;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/components/MediaRecorder/transcode/index.js

@@ -1,11 +1,10 @@
 import { encodeToWaw } from './wav';
 import { encodeToMp3 } from './mp3';
 import { createFileFromBlobs, getExtensionFromMimeType } from '../../ReactFileUtilities';
-export var transcode = function (_a) {
-    var blob = _a.blob, sampleRate = _a.sampleRate, targetMimeType = _a.targetMimeType;
-    var file = createFileFromBlobs({
+export const transcode = ({ blob, sampleRate, targetMimeType }) => {
+    const file = createFileFromBlobs({
         blobsArray: [blob],
-        fileName: "audio_recording_".concat(new Date().toISOString(), ".").concat(getExtensionFromMimeType(blob.type)),
+        fileName: `audio_recording_${new Date().toISOString()}.${getExtensionFromMimeType(blob.type)}`,
         mimeType: blob.type,
     });
     if (targetMimeType.match('audio/wav')) {

package/dist/components/MediaRecorder/transcode/mp3.d.ts

@@ -1,2 +1 @@
 export declare function encodeToMp3(file: File, sampleRate: number): Promise<Blob>;
-//# sourceMappingURL=mp3.d.ts.map

package/dist/components/MediaRecorder/transcode/mp3.js

@@ -1,53 +1,33 @@
-import { __awaiter, __generator } from "tslib";
 import { Mp3Encoder } from '@breezystack/lamejs';
 import { renderAudio, toAudioBuffer } from './audioProcessing';
-var ENCODING_BIT_RATE = 128; // kbps;
-var COUNT_SAMPLES_PER_ENCODED_BLOCK = 1152;
-var float32ArrayToInt16Array = function (float32Arr) {
-    var int16Arr = new Int16Array(float32Arr.length);
-    for (var i = 0; i < float32Arr.length; i++) {
-        var float32Value = float32Arr[i];
+const ENCODING_BIT_RATE = 128; // kbps;
+const COUNT_SAMPLES_PER_ENCODED_BLOCK = 1152;
+const float32ArrayToInt16Array = (float32Arr) => {
+    const int16Arr = new Int16Array(float32Arr.length);
+    for (let i = 0; i < float32Arr.length; i++) {
+        const float32Value = float32Arr[i];
         // Clamp the float value between -1 and 1
-        var clampedValue = Math.max(-1, Math.min(1, float32Value));
+        const clampedValue = Math.max(-1, Math.min(1, float32Value));
         // Convert the float value to a signed 16-bit integer
         int16Arr[i] = Math.round(clampedValue * 32767);
     }
     return int16Arr;
 };
-var splitDataByChannel = function (audioBuffer) {
-    return Array.from({ length: audioBuffer.numberOfChannels }, function (_, i) { return audioBuffer.getChannelData(i); }).map(float32ArrayToInt16Array);
-};
-export function encodeToMp3(file, sampleRate) {
-    return __awaiter(this, void 0, void 0, function () {
-        var audioBuffer, _a, channelCount, dataByChannel, mp3Encoder, dataBuffer, remaining, _loop_1, i, lastBlock;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _a = renderAudio;
-                    return [4 /*yield*/, toAudioBuffer(file)];
-                case 1: return [4 /*yield*/, _a.apply(void 0, [_b.sent(), sampleRate])];
-                case 2:
-                    audioBuffer = _b.sent();
-                    channelCount = audioBuffer.numberOfChannels;
-                    dataByChannel = splitDataByChannel(audioBuffer);
-                    mp3Encoder = new Mp3Encoder(channelCount, sampleRate, ENCODING_BIT_RATE);
-                    dataBuffer = [];
-                    remaining = dataByChannel[0].length;
-                    _loop_1 = function (i) {
-                        var _c = dataByChannel.map(function (channel) {
-                            return channel.subarray(i, i + COUNT_SAMPLES_PER_ENCODED_BLOCK);
-                        }), leftChannelBlock = _c[0], rightChannelBlock = _c[1];
-                        dataBuffer.push(new Int8Array(mp3Encoder.encodeBuffer(leftChannelBlock, rightChannelBlock)));
-                        remaining -= COUNT_SAMPLES_PER_ENCODED_BLOCK;
-                    };
-                    for (i = 0; remaining >= COUNT_SAMPLES_PER_ENCODED_BLOCK; i += COUNT_SAMPLES_PER_ENCODED_BLOCK) {
-                        _loop_1(i);
-                    }
-                    lastBlock = mp3Encoder.flush();
-                    if (lastBlock.length)
-                        dataBuffer.push(new Int8Array(lastBlock));
-                    return [2 /*return*/, new Blob(dataBuffer, { type: 'audio/mp3;sbu_type=voice' })];
-            }
-        });
-    });
+const splitDataByChannel = (audioBuffer) => Array.from({ length: audioBuffer.numberOfChannels }, (_, i) => audioBuffer.getChannelData(i)).map(float32ArrayToInt16Array);
+export async function encodeToMp3(file, sampleRate) {
+    const audioBuffer = await renderAudio(await toAudioBuffer(file), sampleRate);
+    const channelCount = audioBuffer.numberOfChannels;
+    const dataByChannel = splitDataByChannel(audioBuffer);
+    const mp3Encoder = new Mp3Encoder(channelCount, sampleRate, ENCODING_BIT_RATE);
+    const dataBuffer = [];
+    let remaining = dataByChannel[0].length;
+    for (let i = 0; remaining >= COUNT_SAMPLES_PER_ENCODED_BLOCK; i += COUNT_SAMPLES_PER_ENCODED_BLOCK) {
+        const [leftChannelBlock, rightChannelBlock] = dataByChannel.map((channel) => channel.subarray(i, i + COUNT_SAMPLES_PER_ENCODED_BLOCK));
+        dataBuffer.push(new Int8Array(mp3Encoder.encodeBuffer(leftChannelBlock, rightChannelBlock)));
+        remaining -= COUNT_SAMPLES_PER_ENCODED_BLOCK;
+    }
+    const lastBlock = mp3Encoder.flush();
+    if (lastBlock.length)
+        dataBuffer.push(new Int8Array(lastBlock));
+    return new Blob(dataBuffer, { type: 'audio/mp3;sbu_type=voice' });
 }

package/dist/components/MediaRecorder/transcode/wav.d.ts

@@ -5,4 +5,3 @@ export declare const readWavHeader: (dataView: DataView) => {
     sampleRate: number;
 } | undefined;
 export declare const encodeToWaw: (file: File, sampleRate: number) => Promise<Blob>;
-//# sourceMappingURL=wav.d.ts.map

package/dist/components/MediaRecorder/transcode/wav.js

@@ -1,45 +1,41 @@
-import { __awaiter, __generator } from "tslib";
 import { renderAudio, toAudioBuffer } from './audioProcessing';
-var WAV_HEADER_LENGTH_BYTES = 44;
-var BYTES_PER_SAMPLE = 2;
-var RIFF_FILE_MAX_BYTES = 4294967295;
-var HEADER = {
-    AUDIO_FORMAT: { offset: 20, value: 1 },
-    BITS_PER_SAMPLE: { offset: 34, value: BYTES_PER_SAMPLE * 8 },
+const WAV_HEADER_LENGTH_BYTES = 44;
+const BYTES_PER_SAMPLE = 2;
+const RIFF_FILE_MAX_BYTES = 4294967295;
+const HEADER = {
+    AUDIO_FORMAT: { offset: 20, value: 1 }, // PCM = 1
+    BITS_PER_SAMPLE: { offset: 34, value: BYTES_PER_SAMPLE * 8 }, // 16 bits encoding
     BLOCK_ALIGN: { offset: 32 },
     BYTE_RATE: { offset: 28 },
-    CHANNEL_COUNT: { offset: 22 },
-    CHUNK_ID: { offset: 0, value: 0x52494646 },
+    CHANNEL_COUNT: { offset: 22 }, // 1 - mono, 2 - stereo
+    CHUNK_ID: { offset: 0, value: 0x52494646 }, // hex representation of string "RIFF" (Resource Interchange File Format) - identifies the file structure that defines a class of more specific file formats, e.g. WAVE
     CHUNK_SIZE: { offset: 4 },
-    FILE_FORMAT: { offset: 8, value: 0x57415645 },
+    FILE_FORMAT: { offset: 8, value: 0x57415645 }, // hex representation of string "WAVE"
     SAMPLE_RATE: { offset: 24 },
-    SUBCHUNK1_ID: { offset: 12, value: 0x666d7420 },
-    SUBCHUNK1_SIZE: { offset: 16, value: 16 },
-    SUBCHUNK2_ID: { offset: 36, value: 0x64617461 },
+    SUBCHUNK1_ID: { offset: 12, value: 0x666d7420 }, // hex representation of string "fmt " - identifies the start of "format" section of the header
+    SUBCHUNK1_SIZE: { offset: 16, value: 16 }, // Subchunk1 Size without SUBCHUNK1_ID and SUBCHUNK1_SIZE fields
+    SUBCHUNK2_ID: { offset: 36, value: 0x64617461 }, // hex representation of string "data" - identifies the start of actual audio data section
     SUBCHUNK2_SIZE: { offset: 40 }, // actual audio data size
 };
-var fourCharsToInt = function (chars) {
-    return (chars.charCodeAt(0) << 24) |
-        (chars.charCodeAt(1) << 16) |
-        (chars.charCodeAt(2) << 8) |
-        chars.charCodeAt(3);
-};
-var WAV_HEADER_FLAGS = {
+const fourCharsToInt = (chars) => (chars.charCodeAt(0) << 24) |
+    (chars.charCodeAt(1) << 16) |
+    (chars.charCodeAt(2) << 8) |
+    chars.charCodeAt(3);
+const WAV_HEADER_FLAGS = {
     data: fourCharsToInt('data'),
     fmt: fourCharsToInt('fmt '),
     RIFF: fourCharsToInt('RIFF'),
     WAVE: fourCharsToInt('WAVE'),
 };
-var writeWavHeader = function (_a) {
-    var arrayBuffer = _a.arrayBuffer, channelCount = _a.channelCount, sampleRate = _a.sampleRate;
-    var byteRate = sampleRate * channelCount * BYTES_PER_SAMPLE; // bytes/sec
-    var blockAlign = channelCount * BYTES_PER_SAMPLE;
-    var dataView = new DataView(arrayBuffer);
+const writeWavHeader = ({ arrayBuffer, channelCount, sampleRate }) => {
+    const byteRate = sampleRate * channelCount * BYTES_PER_SAMPLE; // bytes/sec
+    const blockAlign = channelCount * BYTES_PER_SAMPLE;
+    const dataView = new DataView(arrayBuffer);
     /*
      * The maximum size of a RIFF file is 4294967295 bytes and since the header takes up 44 bytes there are 4294967251 bytes left for the
      * data chunk.
      */
-    var dataChunkSize = Math.min(dataView.byteLength - WAV_HEADER_LENGTH_BYTES, RIFF_FILE_MAX_BYTES - WAV_HEADER_LENGTH_BYTES);
+    const dataChunkSize = Math.min(dataView.byteLength - WAV_HEADER_LENGTH_BYTES, RIFF_FILE_MAX_BYTES - WAV_HEADER_LENGTH_BYTES);
     dataView.setUint32(HEADER.CHUNK_ID.offset, HEADER.CHUNK_ID.value); // "RIFF"
     dataView.setUint32(HEADER.CHUNK_SIZE.offset, arrayBuffer.byteLength - 8, true); // adjustment for the first two headers - chunk id + file size
     dataView.setUint32(HEADER.FILE_FORMAT.offset, HEADER.FILE_FORMAT.value); // "WAVE"
@@ -54,8 +50,8 @@ var writeWavHeader = function (_a) {
     dataView.setUint32(HEADER.SUBCHUNK2_ID.offset, HEADER.SUBCHUNK2_ID.value); // "data"
     dataView.setUint32(HEADER.SUBCHUNK2_SIZE.offset, dataChunkSize, true);
 };
-export var readWavHeader = function (dataView) {
-    var header = dataView.getUint32(0, false);
+export const readWavHeader = (dataView) => {
+    const header = dataView.getUint32(0, false);
     if (WAV_HEADER_FLAGS.RIFF !== header) {
         console.error('Missing RIFF header in WAVE file');
         return;
@@ -75,43 +71,30 @@ export var readWavHeader = function (dataView) {
         sampleRate: dataView.getUint32(HEADER.SAMPLE_RATE.offset, true),
     };
 };
-var splitDataByChannel = function (audioBuffer) {
-    return Array.from({ length: audioBuffer.numberOfChannels }, function (_, i) { return audioBuffer.getChannelData(i); });
-};
+const splitDataByChannel = (audioBuffer) => Array.from({ length: audioBuffer.numberOfChannels }, (_, i) => audioBuffer.getChannelData(i));
 /**
  * In a WAV file, samples for each channel are usually interleaved, meaning samples from each channel are grouped together sequentially.
  * For example, in a stereo audio file (2 channels), samples alternate between the left and right channels.
  * @param arrayBuffer
  * @param dataByChannel
  */
-var writeWavAudioData = function (_a) {
-    var arrayBuffer = _a.arrayBuffer, dataByChannel = _a.dataByChannel;
-    var dataView = new DataView(arrayBuffer);
-    var channelCount = dataByChannel.length;
-    dataByChannel.forEach(function (channelData, channelIndex) {
-        var writeOffset = WAV_HEADER_LENGTH_BYTES + channelCount * channelIndex;
-        channelData.forEach(function (float32Value) {
+const writeWavAudioData = ({ arrayBuffer, dataByChannel }) => {
+    const dataView = new DataView(arrayBuffer);
+    const channelCount = dataByChannel.length;
+    dataByChannel.forEach((channelData, channelIndex) => {
+        let writeOffset = WAV_HEADER_LENGTH_BYTES + channelCount * channelIndex;
+        channelData.forEach((float32Value) => {
             dataView.setInt16(writeOffset, float32Value < 0 ? Math.max(-1, float32Value) * 32768 : Math.min(1, float32Value) * 32767, true);
             writeOffset += channelCount * BYTES_PER_SAMPLE;
         });
     });
 };
-export var encodeToWaw = function (file, sampleRate) { return __awaiter(void 0, void 0, void 0, function () {
-    var audioBuffer, _a, numberOfSamples, fileSizeBytes, arrayBuffer;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                _a = renderAudio;
-                return [4 /*yield*/, toAudioBuffer(file)];
-            case 1: return [4 /*yield*/, _a.apply(void 0, [_b.sent(), sampleRate])];
-            case 2:
-                audioBuffer = _b.sent();
-                numberOfSamples = audioBuffer.duration * sampleRate;
-                fileSizeBytes = numberOfSamples * audioBuffer.numberOfChannels * BYTES_PER_SAMPLE + WAV_HEADER_LENGTH_BYTES;
-                arrayBuffer = new ArrayBuffer(fileSizeBytes);
-                writeWavHeader({ arrayBuffer: arrayBuffer, channelCount: audioBuffer.numberOfChannels, sampleRate: sampleRate });
-                writeWavAudioData({ arrayBuffer: arrayBuffer, dataByChannel: splitDataByChannel(audioBuffer) });
-                return [2 /*return*/, new Blob([arrayBuffer], { type: 'audio/wav' })];
-        }
-    });
-}); };
+export const encodeToWaw = async (file, sampleRate) => {
+    const audioBuffer = await renderAudio(await toAudioBuffer(file), sampleRate);
+    const numberOfSamples = audioBuffer.duration * sampleRate;
+    const fileSizeBytes = numberOfSamples * audioBuffer.numberOfChannels * BYTES_PER_SAMPLE + WAV_HEADER_LENGTH_BYTES;
+    const arrayBuffer = new ArrayBuffer(fileSizeBytes);
+    writeWavHeader({ arrayBuffer, channelCount: audioBuffer.numberOfChannels, sampleRate });
+    writeWavAudioData({ arrayBuffer, dataByChannel: splitDataByChannel(audioBuffer) });
+    return new Blob([arrayBuffer], { type: 'audio/wav' });
+};

package/dist/components/Message/FixedHeightMessage.d.ts

@@ -12,4 +12,3 @@ export type FixedHeightMessageProps<StreamChatGenerics extends DefaultStreamChat
  * It uses fixed height elements to make sure it works well in VirtualizedMessageList
  */
 export declare const FixedHeightMessage: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>(props: FixedHeightMessageProps<StreamChatGenerics>) => React.JSX.Element;
-//# sourceMappingURL=FixedHeightMessage.d.ts.map