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

package/dist/components/MediaRecorder/classes/AmplitudeRecorder.js

@@ -1,13 +1,10 @@
-import { __assign, __spreadArray } from "tslib";
 import { BehaviorSubject } from '../observable/BehaviorSubject';
 import { Subject } from '../observable/Subject';
 import { mergeDeepUndefined } from '../../../utils/mergeDeep';
-var MAX_FREQUENCY_AMPLITUDE = 255;
-var logError = function (e) { return e && console.error('[AMPLITUDE RECORDER ERROR]', e); };
-var rootMeanSquare = function (values) {
-    return Math.sqrt(values.reduce(function (acc, val) { return acc + Math.pow(val, 2); }, 0) / values.length);
-};
-export var DEFAULT_AMPLITUDE_RECORDER_CONFIG = {
+const MAX_FREQUENCY_AMPLITUDE = 255;
+const logError = (e) => e && console.error('[AMPLITUDE RECORDER ERROR]', e);
+const rootMeanSquare = (values) => Math.sqrt(values.reduce((acc, val) => acc + Math.pow(val, 2), 0) / values.length);
+export const DEFAULT_AMPLITUDE_RECORDER_CONFIG = {
     analyserConfig: {
         fftSize: 32,
         maxDecibels: 0,
@@ -22,72 +19,67 @@ export var AmplitudeRecorderState;
     AmplitudeRecorderState["RECORDING"] = "recording";
     AmplitudeRecorderState["STOPPED"] = "stopped";
 })(AmplitudeRecorderState || (AmplitudeRecorderState = {}));
-var AmplitudeRecorder = /** @class */ (function () {
-    function AmplitudeRecorder(_a) {
-        var config = _a.config, stream = _a.stream;
-        var _this = this;
+export class AmplitudeRecorder {
+    constructor({ config, stream }) {
         this.amplitudes = new BehaviorSubject([]);
         this.state = new BehaviorSubject(undefined);
         this.error = new Subject();
-        this.start = function () {
-            if (_this.state.value === AmplitudeRecorderState.CLOSED)
+        this.start = () => {
+            if (this.state.value === AmplitudeRecorderState.CLOSED)
                 return;
-            if (!_this.stream) {
+            if (!this.stream) {
                 throw new Error('Missing MediaStream instance. Cannot to start amplitude recording');
             }
-            if (_this.state.value === AmplitudeRecorderState.RECORDING)
-                _this.stop();
-            if (!_this.analyserNode) {
-                if (!_this.stream)
+            if (this.state.value === AmplitudeRecorderState.RECORDING)
+                this.stop();
+            if (!this.analyserNode) {
+                if (!this.stream)
                     return;
-                _this.init();
+                this.init();
             }
-            _this.state.next(AmplitudeRecorderState.RECORDING);
-            _this.amplitudeSamplingInterval = setInterval(function () {
-                if (!(_this.analyserNode && _this.state.value === AmplitudeRecorderState.RECORDING))
+            this.state.next(AmplitudeRecorderState.RECORDING);
+            this.amplitudeSamplingInterval = setInterval(() => {
+                if (!(this.analyserNode && this.state.value === AmplitudeRecorderState.RECORDING))
                     return;
-                var frequencyBins = new Uint8Array(_this.analyserNode.frequencyBinCount);
+                const frequencyBins = new Uint8Array(this.analyserNode.frequencyBinCount);
                 try {
-                    _this.analyserNode.getByteFrequencyData(frequencyBins);
+                    this.analyserNode.getByteFrequencyData(frequencyBins);
                 }
                 catch (e) {
                     logError(e);
-                    _this.error.next(e);
+                    this.error.next(e);
                     return;
                 }
-                var normalizedSignalStrength = rootMeanSquare(frequencyBins) / MAX_FREQUENCY_AMPLITUDE;
-                _this.amplitudes.next(__spreadArray(__spreadArray([], _this.amplitudes.value, true), [normalizedSignalStrength], false));
-            }, _this.config.samplingFrequencyMs);
+                const normalizedSignalStrength = rootMeanSquare(frequencyBins) / MAX_FREQUENCY_AMPLITUDE;
+                this.amplitudes.next([...this.amplitudes.value, normalizedSignalStrength]);
+            }, this.config.samplingFrequencyMs);
         };
-        this.config = mergeDeepUndefined(__assign({}, config), DEFAULT_AMPLITUDE_RECORDER_CONFIG);
+        this.config = mergeDeepUndefined({ ...config }, DEFAULT_AMPLITUDE_RECORDER_CONFIG);
         this.stream = stream;
     }
-    AmplitudeRecorder.prototype.init = function () {
+    init() {
         this.audioContext = new AudioContext();
         this.analyserNode = this.audioContext.createAnalyser();
-        var analyserConfig = this.config.analyserConfig;
+        const { analyserConfig } = this.config;
         this.analyserNode.fftSize = analyserConfig.fftSize;
         this.analyserNode.maxDecibels = analyserConfig.maxDecibels;
         this.analyserNode.minDecibels = analyserConfig.minDecibels;
         this.microphone = this.audioContext.createMediaStreamSource(this.stream);
         this.microphone.connect(this.analyserNode);
-    };
-    AmplitudeRecorder.prototype.stop = function () {
+    }
+    stop() {
         clearInterval(this.amplitudeSamplingInterval);
         this.amplitudeSamplingInterval = undefined;
         this.state.next(AmplitudeRecorderState.STOPPED);
-    };
-    AmplitudeRecorder.prototype.close = function () {
-        var _a, _b, _c, _d;
+    }
+    close() {
         if (this.state.value !== AmplitudeRecorderState.STOPPED)
             this.stop();
         this.state.next(AmplitudeRecorderState.CLOSED);
         this.amplitudes.next([]);
-        (_a = this.microphone) === null || _a === void 0 ? void 0 : _a.disconnect();
-        (_b = this.analyserNode) === null || _b === void 0 ? void 0 : _b.disconnect();
-        if (((_c = this.audioContext) === null || _c === void 0 ? void 0 : _c.state) !== 'closed')
-            (_d = this.audioContext) === null || _d === void 0 ? void 0 : _d.close();
-    };
-    return AmplitudeRecorder;
-}());
-export { AmplitudeRecorder };
+        this.microphone?.disconnect();
+        this.analyserNode?.disconnect();
+        if (this.audioContext?.state !== 'closed')
+            this.audioContext?.close();
+    }
+}

package/dist/components/MediaRecorder/classes/BrowserPermission.d.ts

@@ -20,4 +20,3 @@ export declare class BrowserPermission {
     unwatch(): void;
     check(): Promise<void>;
 }
-//# sourceMappingURL=BrowserPermission.d.ts.map

package/dist/components/MediaRecorder/classes/BrowserPermission.js

@@ -1,4 +1,3 @@
-import { __awaiter, __generator } from "tslib";
 import { Subscription } from '../observable/Subscription';
 import { Subject } from '../observable/Subject';
 import { BehaviorSubject } from '../observable/BehaviorSubject';
@@ -7,92 +6,58 @@ export var RecordingPermission;
     RecordingPermission["CAM"] = "camera";
     RecordingPermission["MIC"] = "microphone";
 })(RecordingPermission || (RecordingPermission = {}));
-var MEDIA_TO_PERMISSION = {
+const MEDIA_TO_PERMISSION = {
     audio: RecordingPermission.MIC,
     video: RecordingPermission.CAM,
 };
-var BrowserPermission = /** @class */ (function () {
-    function BrowserPermission(_a) {
-        var mediaType = _a.mediaType;
+export class BrowserPermission {
+    constructor({ mediaType }) {
         this.state = new BehaviorSubject(undefined);
         this.status = new BehaviorSubject(undefined);
         this.error = new Subject();
         this.changeSubscriptions = [];
         this.name = MEDIA_TO_PERMISSION[mediaType];
     }
-    Object.defineProperty(BrowserPermission.prototype, "isWatching", {
-        get: function () {
-            return this.changeSubscriptions.some(function (subscription) { return !subscription.closed; });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    BrowserPermission.prototype.watch = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var status, handlePermissionChange;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!!this.status.value) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.check()];
-                    case 1:
-                        _a.sent();
-                        if (!this.status.value)
-                            return [2 /*return*/];
-                        _a.label = 2;
-                    case 2:
-                        status = this.status.value;
-                        handlePermissionChange = function (e) {
-                            var state = e.target.state;
-                            _this.state.next(state);
-                        };
-                        status.addEventListener('change', handlePermissionChange);
-                        this.changeSubscriptions.push(new Subscription(function () {
-                            status.removeEventListener('change', handlePermissionChange);
-                        }));
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    BrowserPermission.prototype.unwatch = function () {
-        this.changeSubscriptions.forEach(function (subscription) { return subscription.unsubscribe(); });
-    };
-    BrowserPermission.prototype.check = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var permissionState, permissionStatus, e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.name) {
-                            this.error.next(new Error('Unknown media recording permission'));
-                            return [2 /*return*/];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, navigator.permissions.query({
-                                name: this.name,
-                            })];
-                    case 2:
-                        permissionStatus = _a.sent();
-                        permissionState = permissionStatus.state;
-                        this.status.next(permissionStatus);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_1 = _a.sent();
-                        // permission does not exist - cannot be queried
-                        // an example would be Firefox - camera, neither microphone perms can be queried
-                        permissionState = 'granted';
-                        return [3 /*break*/, 4];
-                    case 4:
-                        this.state.next(permissionState);
-                        return [2 /*return*/];
-                }
+    get isWatching() {
+        return this.changeSubscriptions.some((subscription) => !subscription.closed);
+    }
+    async watch() {
+        if (!this.status.value) {
+            await this.check();
+            if (!this.status.value)
+                return;
+        }
+        const status = this.status.value;
+        const handlePermissionChange = (e) => {
+            const { state } = e.target;
+            this.state.next(state);
+        };
+        status.addEventListener('change', handlePermissionChange);
+        this.changeSubscriptions.push(new Subscription(() => {
+            status.removeEventListener('change', handlePermissionChange);
+        }));
+    }
+    unwatch() {
+        this.changeSubscriptions.forEach((subscription) => subscription.unsubscribe());
+    }
+    async check() {
+        if (!this.name) {
+            this.error.next(new Error('Unknown media recording permission'));
+            return;
+        }
+        let permissionState;
+        try {
+            const permissionStatus = await navigator.permissions.query({
+                name: this.name,
             });
-        });
-    };
-    return BrowserPermission;
-}());
-export { BrowserPermission };
+            permissionState = permissionStatus.state;
+            this.status.next(permissionStatus);
+        }
+        catch (e) {
+            // permission does not exist - cannot be queried
+            // an example would be Firefox - camera, neither microphone perms can be queried
+            permissionState = 'granted';
+        }
+        this.state.next(permissionState);
+    }
+}

package/dist/components/MediaRecorder/classes/MediaRecorderController.d.ts

@@ -46,7 +46,7 @@ export declare class MediaRecorderController<StreamChatGenerics extends DefaultS
     mediaType: RecordedMediaType;
     signalRecordingReady: ((r: LocalVoiceRecordingAttachment<StreamChatGenerics>) => void) | undefined;
     recordingState: BehaviorSubject<MediaRecordingState | undefined>;
-    recording: BehaviorSubject<LocalVoiceRecordingAttachment<StreamChatGenerics, Record<string, unknown>> | undefined>;
+    recording: BehaviorSubject<LocalVoiceRecordingAttachment<StreamChatGenerics> | undefined>;
     error: Subject<Error | undefined>;
     notification: Subject<{
         text: string;
@@ -77,8 +77,7 @@ export declare class MediaRecorderController<StreamChatGenerics extends DefaultS
     start: () => Promise<void>;
     pause: () => void;
     resume: () => void;
-    stop: () => Promise<undefined> | Promise<LocalVoiceRecordingAttachment<StreamChatGenerics, Record<string, unknown>>>;
+    stop: () => Promise<undefined> | Promise<LocalVoiceRecordingAttachment<StreamChatGenerics>>;
     cancel: () => void;
 }
 export {};
-//# sourceMappingURL=MediaRecorderController.d.ts.map