stream-chat-react 11.14.0 → 11.15.1

package/dist/components/MediaRecorder/observable/BehaviorSubject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BehaviorSubject.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/observable/BehaviorSubject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAkB,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IACpC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,CAAC;IAI7B,IAAI,KAAK,IAAI,CAAC,CAMb;IAED,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,YAAY;IAO1D,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;CAGrB"}

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

@@ -0,0 +1,34 @@
+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;
+    }
+    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);
+        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 };

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

@@ -0,0 +1,18 @@
+import { ObserverOrNext } from './Observer';
+import { Subscription } from './Subscription';
+export interface Unsubscribable {
+    unsubscribe(): void;
+}
+type Producer<T> = (observer: ObserverOrNext<T>) => Subscription;
+export interface Subscribable<T> {
+    subscribe(observerOrNext: ObserverOrNext<T>): Unsubscribable;
+}
+export declare class Observable<T> implements Subscribable<T> {
+    protected _closed: boolean;
+    private _producer;
+    constructor(producer?: Producer<T>);
+    get closed(): boolean;
+    subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
+}
+export {};
+//# sourceMappingURL=Observable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Observable.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/observable/Observable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,WAAW,cAAc;IAC7B,WAAW,IAAI,IAAI,CAAC;CACrB;AAED,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,YAAY,CAAC;AAEjE,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC;CAC9D;AAED,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,YAAY,CAAC,CAAC,CAAC;IACnD,SAAS,CAAC,OAAO,UAAS;IAC1B,OAAO,CAAC,SAAS,CAA0B;gBAE/B,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC;IAIlC,IAAI,MAAM,YAET;IAED,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,YAAY;CAS3D"}

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

@@ -0,0 +1,29 @@
+import { createObserver } from './Observer';
+import { Subscription } from './Subscription';
+var Observable = /** @class */ (function () {
+    function Observable(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);
+        if (!this.closed) {
+            (_a = this._producer) === null || _a === void 0 ? void 0 : _a.call(this, observer);
+        }
+        return new Subscription(function () {
+            _this._closed = true;
+        });
+    };
+    return Observable;
+}());
+export { Observable };

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

@@ -0,0 +1,10 @@
+type Next<T> = (value: T) => void;
+export type Observer<T> = {
+    next(value: T): void;
+    complete?(): void;
+    error?(error: Error): void;
+};
+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/Observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Observer.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/observable/Observer.ts"],"names":[],"mappings":"AAAA,KAAK,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAClC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI;IACxB,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACrB,QAAQ,CAAC,IAAI,IAAI,CAAC;IAClB,KAAK,CAAC,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC5B,CAAC;AACF,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;AAEtD,wBAAgB,cAAc,CAAC,CAAC,EAAE,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAEhF"}

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

@@ -0,0 +1,3 @@
+export function createObserver(observerOrNext) {
+    return typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;
+}

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

@@ -0,0 +1,16 @@
+import { Observable } from './Observable';
+import { Subscription, SubscriptionLike } from './Subscription';
+import { Observer, ObserverOrNext } from './Observer';
+export declare class Subject<T> extends Observable<T> implements SubscriptionLike {
+    private _observers;
+    private _observerCounter;
+    thrownError: Error | undefined;
+    constructor();
+    get observers(): Observer<T>[];
+    next(value: T): void;
+    error(err: Error): void;
+    complete(): void;
+    subscribe(observerOrNext: ObserverOrNext<T>): Subscription;
+    unsubscribe(): void;
+}
+//# sourceMappingURL=Subject.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Subject.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/observable/Subject.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAkB,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEtE,qBAAa,OAAO,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAE,YAAW,gBAAgB;IACvE,OAAO,CAAC,UAAU,CAAuC;IACzD,OAAO,CAAC,gBAAgB,CAAK;IAC7B,WAAW,EAAE,KAAK,GAAG,SAAS,CAAC;;IAM/B,IAAI,SAAS,kBAEZ;IAED,IAAI,CAAC,KAAK,EAAE,CAAC;IAQb,KAAK,CAAC,GAAG,EAAE,KAAK;IAUhB,QAAQ;IAUR,SAAS,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,YAAY;IAe1D,WAAW,IAAI,IAAI;CAIpB"}

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

@@ -0,0 +1,70 @@
+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;
+    }
+    Object.defineProperty(Subject.prototype, "observers", {
+        get: function () {
+            return Array.from(this._observers.values());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Subject.prototype.next = function (value) {
+        if (this.closed)
+            return;
+        var observers = this.observers;
+        for (var i = 0; i < observers.length; i++) {
+            observers[i].next(value);
+        }
+    };
+    Subject.prototype.error = function (err) {
+        var _a, _b;
+        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);
+        }
+        this._observers.clear();
+    };
+    Subject.prototype.complete = function () {
+        var _a, _b;
+        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);
+        }
+        this._observers.clear();
+    };
+    Subject.prototype.subscribe = function (observerOrNext) {
+        var _this = this;
+        var observer = createObserver(observerOrNext);
+        if (this.thrownError || this.closed) {
+            var subscription = new Subscription();
+            subscription.closed = true;
+            return subscription;
+        }
+        var observerId = this._observerCounter++;
+        this._observers.set(observerId, observer);
+        return new Subscription(function () {
+            _this._observers.delete(observerId);
+        });
+    };
+    Subject.prototype.unsubscribe = function () {
+        this._closed = true;
+        this._observers.clear();
+    };
+    return Subject;
+}(Observable));
+export { Subject };

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

@@ -0,0 +1,11 @@
+export interface SubscriptionLike {
+    closed: boolean;
+    unsubscribe(): void;
+}
+export declare class Subscription implements SubscriptionLike {
+    closed: boolean;
+    private _unsubscribe;
+    constructor(unsubscribe?: () => void);
+    unsubscribe(): void;
+}
+//# sourceMappingURL=Subscription.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Subscription.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/observable/Subscription.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAEhB,WAAW,IAAI,IAAI,CAAC;CACrB;AAED,qBAAa,YAAa,YAAW,gBAAgB;IACnD,MAAM,UAAS;IACf,OAAO,CAAC,YAAY,CAA2B;gBAEnC,WAAW,CAAC,EAAE,MAAM,IAAI;IAIpC,WAAW;CAIZ"}

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

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

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

@@ -0,0 +1,6 @@
+export * from './BehaviorSubject';
+export * from './Observable';
+export * from './Observer';
+export * from './Subject';
+export * from './Subscription';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/observable/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from './BehaviorSubject';
+export * from './Observable';
+export * from './Observer';
+export * from './Subject';
+export * from './Subscription';

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

@@ -0,0 +1,16 @@
+/**
+ * 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 declare const toAudioBuffer: (file: File) => Promise<AudioBuffer>;
+/**
+ * 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
+ */
+export declare const renderAudio: (audioBuffer: AudioBuffer, sampleRate: number) => Promise<AudioBuffer>;
+//# sourceMappingURL=audioProcessing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"audioProcessing.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/transcode/audioProcessing.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,aAAa,SAAgB,IAAI,yBAO7C,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,gBAAuB,WAAW,cAAc,MAAM,yBAY7E,CAAC"}

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

@@ -0,0 +1,51 @@
+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];
+        }
+    });
+}); };
+/**
+ * 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
+ */
+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()];
+        }
+    });
+}); };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/transcode/index.ts"],"names":[],"mappings":"AAIA,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,IAAI,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,eAAO,MAAM,SAAS,yCAA0C,eAAe,KAAG,QAAQ,IAAI,CAe7F,CAAC"}

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

@@ -0,0 +1,18 @@
+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({
+        blobsArray: [blob],
+        fileName: "audio_recording_".concat(new Date().toISOString(), ".").concat(getExtensionFromMimeType(blob.type)),
+        mimeType: blob.type,
+    });
+    if (targetMimeType.match('audio/wav')) {
+        return encodeToWaw(file, sampleRate);
+    }
+    if (targetMimeType.match('audio/mp3')) {
+        return encodeToMp3(file, sampleRate);
+    }
+    return Promise.resolve(blob);
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"mp3.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/transcode/mp3.ts"],"names":[],"mappings":"AAuBA,wBAAsB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,iBAuB/D"}

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

@@ -0,0 +1,53 @@
+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];
+        // Clamp the float value between -1 and 1
+        var 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' })];
+            }
+        });
+    });
+}

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

@@ -0,0 +1,8 @@
+export declare const readWavHeader: (dataView: DataView) => {
+    audioDataSizeBytes: number;
+    audioDataStartOffset: 44;
+    channelCount: number;
+    sampleRate: number;
+} | undefined;
+export declare const encodeToWaw: (file: File, sampleRate: number) => Promise<Blob>;
+//# sourceMappingURL=wav.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wav.d.ts","sourceRoot":"","sources":["../../../../src/components/MediaRecorder/transcode/wav.ts"],"names":[],"mappings":"AAyEA,eAAO,MAAM,aAAa,aAAc,QAAQ;;;;;aAqB/C,CAAC;AAkCF,eAAO,MAAM,WAAW,SAAgB,IAAI,cAAc,MAAM,kBAU/D,CAAC"}

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

@@ -0,0 +1,117 @@
+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 },
+    BLOCK_ALIGN: { offset: 32 },
+    BYTE_RATE: { offset: 28 },
+    CHANNEL_COUNT: { offset: 22 },
+    CHUNK_ID: { offset: 0, value: 0x52494646 },
+    CHUNK_SIZE: { offset: 4 },
+    FILE_FORMAT: { offset: 8, value: 0x57415645 },
+    SAMPLE_RATE: { offset: 24 },
+    SUBCHUNK1_ID: { offset: 12, value: 0x666d7420 },
+    SUBCHUNK1_SIZE: { offset: 16, value: 16 },
+    SUBCHUNK2_ID: { offset: 36, value: 0x64617461 },
+    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 = {
+    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);
+    /*
+     * 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);
+    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"
+    dataView.setUint32(HEADER.SUBCHUNK1_ID.offset, HEADER.SUBCHUNK1_ID.value); // "fmt "
+    dataView.setUint32(HEADER.SUBCHUNK1_SIZE.offset, HEADER.SUBCHUNK1_SIZE.value, true);
+    dataView.setUint16(HEADER.AUDIO_FORMAT.offset, HEADER.AUDIO_FORMAT.value, true);
+    dataView.setUint16(HEADER.CHANNEL_COUNT.offset, channelCount, true);
+    dataView.setUint32(HEADER.SAMPLE_RATE.offset, sampleRate, true);
+    dataView.setUint32(HEADER.BYTE_RATE.offset, byteRate, true);
+    dataView.setUint16(HEADER.BLOCK_ALIGN.offset, blockAlign, true);
+    dataView.setUint16(HEADER.BITS_PER_SAMPLE.offset, HEADER.BITS_PER_SAMPLE.value, true);
+    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);
+    if (WAV_HEADER_FLAGS.RIFF !== header) {
+        console.error('Missing RIFF header in WAVE file');
+        return;
+    }
+    if (WAV_HEADER_FLAGS.WAVE !== dataView.getUint32(HEADER.FILE_FORMAT.offset, false)) {
+        console.error('Missing WAVE header in WAVE file');
+        return;
+    }
+    if (WAV_HEADER_FLAGS.fmt !== dataView.getUint32(HEADER.SUBCHUNK1_ID.offset, false)) {
+        console.error('Missing fmt header in WAVE file');
+        return;
+    }
+    return {
+        audioDataSizeBytes: dataView.getUint32(HEADER.SUBCHUNK2_SIZE.offset, true),
+        audioDataStartOffset: WAV_HEADER_LENGTH_BYTES,
+        channelCount: dataView.getUint16(HEADER.CHANNEL_COUNT.offset, true),
+        sampleRate: dataView.getUint32(HEADER.SAMPLE_RATE.offset, true),
+    };
+};
+var splitDataByChannel = function (audioBuffer) {
+    return Array.from({ length: audioBuffer.numberOfChannels }, function (_, i) { return 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) {
+            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' })];
+        }
+    });
+}); };

package/dist/components/MessageInput/AttachmentPreviewList.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
-export declare const AttachmentPreviewList: () => React.JSX.Element;
+import type { DefaultStreamChatGenerics } from '../../types';
+export declare const AttachmentPreviewList: <StreamChatGenerics extends DefaultStreamChatGenerics = DefaultStreamChatGenerics>() => React.JSX.Element;
 type PreviewItemProps = {
     id: string;
 };

package/dist/components/MessageInput/AttachmentPreviewList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AttachmentPreviewList.d.ts","sourceRoot":"","sources":["../../../src/components/MessageInput/AttachmentPreviewList.tsx"],"names":[],"mappings":"AACA,OAAO,KAAgC,MAAM,OAAO,CAAC;AASrD,eAAO,MAAM,qBAAqB,yBAkBjC,CAAC;AAEF,KAAK,gBAAgB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,eAAO,MAAM,gBAAgB,WAAY,gBAAgB,6BA+DxD,CAAC"}
+{"version":3,"file":"AttachmentPreviewList.d.ts","sourceRoot":"","sources":["../../../src/components/MessageInput/AttachmentPreviewList.tsx"],"names":[],"mappings":"AACA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAgBrD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,eAAO,MAAM,qBAAqB,2GAmDjC,CAAC;AA2GF,KAAK,gBAAgB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvC,eAAO,MAAM,gBAAgB,WAAY,gBAAgB,6BA+DxD,CAAC"}