stream-chat-angular 5.3.2 → 5.4.1

package/esm2020/lib/voice-recorder/media-recorder.mjs

@@ -0,0 +1,190 @@
+import { BehaviorSubject } from 'rxjs';
+import { createFileFromBlobs, createUriFromBlob, getExtensionFromMimeType, } from '../file-utils';
+import fixWebmDuration from 'fix-webm-duration';
+export var MediaRecordingState;
+(function (MediaRecordingState) {
+    MediaRecordingState["PAUSED"] = "paused";
+    MediaRecordingState["RECORDING"] = "recording";
+    MediaRecordingState["STOPPED"] = "stopped";
+    MediaRecordingState["ERROR"] = "error";
+})(MediaRecordingState || (MediaRecordingState = {}));
+export class MultimediaRecorder {
+    constructor(notificationService, chatService, transcoder) {
+        this.notificationService = notificationService;
+        this.chatService = chatService;
+        this.transcoder = transcoder;
+        this.recordingSubject = new BehaviorSubject(undefined);
+        this.recordedChunkDurations = [];
+        this.recordingStateSubject = new BehaviorSubject(MediaRecordingState.STOPPED);
+        this.generateRecordingTitle = (mimeType) => {
+            if (this.customGenerateRecordingTitle) {
+                return this.customGenerateRecordingTitle({ mimeType });
+            }
+            else {
+                return `${this.mediaType}_recording_${new Date().toISOString()}.${getExtensionFromMimeType(mimeType)}`; // extension needed so that desktop Safari can play the asset
+            }
+        };
+        this.handleErrorEvent = (e) => {
+            /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+            this.logError(e.error);
+            this.recordingStateSubject.next(MediaRecordingState.ERROR);
+            this.notificationService.addTemporaryNotification('streamChat.An error has occurred during recording');
+            void this.stop({ cancel: true });
+        };
+        this.handleDataavailableEvent = (e) => {
+            if (!e.data.size)
+                return;
+            void this.makeRecording(e.data);
+        };
+        this.recording$ = this.recordingSubject.asObservable();
+        this.recordingState$ = this.recordingStateSubject.asObservable();
+    }
+    get durationMs() {
+        return (this.recordedChunkDurations.reduce((acc, val) => acc + val, 0) +
+            (this.startTime ? Date.now() - this.startTime : 0));
+    }
+    get mediaType() {
+        return this.config.mimeType.split('/')?.[0] || 'unknown';
+    }
+    get isRecording() {
+        return (this.recordingStateSubject.value === MediaRecordingState.RECORDING ||
+            this.recordingStateSubject.value === MediaRecordingState.PAUSED);
+    }
+    async makeRecording(blob) {
+        const { mimeType } = this.config;
+        try {
+            if (mimeType.includes('webm')) {
+                // The browser does not include duration metadata with the recorded blob
+                blob = await fixWebmDuration(blob, this.durationMs, {
+                    logger: () => null, // prevents polluting the browser console
+                });
+            }
+            blob = await this.transcoder.transcode(blob);
+            if (!blob)
+                return;
+            const file = createFileFromBlobs({
+                blobsArray: [blob],
+                fileName: this.generateRecordingTitle(blob.type),
+                mimeType: blob.type,
+            });
+            const previewUrl = await createUriFromBlob(file);
+            const extraData = this.enrichWithExtraData();
+            this.recordingSubject.next({
+                recording: file,
+                duration: this.durationMs / 1000,
+                asset_url: previewUrl,
+                mime_type: mimeType,
+                ...extraData,
+            });
+            return file;
+        }
+        catch (error) {
+            this.logError(error);
+            this.recordingStateSubject.next(MediaRecordingState.ERROR);
+            return undefined;
+        }
+    }
+    get recordingState() {
+        return this.recordingStateSubject.value;
+    }
+    async start() {
+        if ([MediaRecordingState.RECORDING, MediaRecordingState.PAUSED].includes(this.recordingStateSubject.value)) {
+            return;
+        }
+        this.recordingSubject.next(undefined);
+        // account for requirement on iOS as per this bug report: https://bugs.webkit.org/show_bug.cgi?id=252303
+        if (!navigator.mediaDevices) {
+            console.warn(`[Stream Chat] Media devices API missing, it's possible your app is not served from a secure context (https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts)`);
+            const error = new Error('Media recording is not supported');
+            this.logError(error);
+            this.recordingStateSubject.next(MediaRecordingState.ERROR);
+            this.notificationService.addTemporaryNotification(`streamChat.Media recording not supported`);
+            return;
+        }
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            this.mediaRecorder = new MediaRecorder(stream, this.config);
+            this.mediaRecorder.addEventListener('dataavailable', this.handleDataavailableEvent);
+            this.mediaRecorder.addEventListener('error', this.handleErrorEvent);
+            this.startTime = new Date().getTime();
+            this.mediaRecorder.start();
+            this.recordingStateSubject.next(MediaRecordingState.RECORDING);
+        }
+        catch (error) {
+            this.logError(error);
+            void this.stop({ cancel: true });
+            this.recordingStateSubject.next(MediaRecordingState.ERROR);
+            const isNotAllowed = error.name?.includes('NotAllowedError');
+            this.notificationService.addTemporaryNotification(isNotAllowed
+                ? `streamChat.Please grant permission to use microhpone`
+                : `streamChat.Error starting recording`);
+        }
+    }
+    pause() {
+        if (this.recordingStateSubject.value !== MediaRecordingState.RECORDING)
+            return;
+        if (this.startTime) {
+            this.recordedChunkDurations.push(new Date().getTime() - this.startTime);
+            this.startTime = undefined;
+        }
+        this.mediaRecorder?.pause();
+        this.recordingStateSubject.next(MediaRecordingState.PAUSED);
+    }
+    resume() {
+        if (this.recordingStateSubject.value !== MediaRecordingState.PAUSED)
+            return;
+        this.startTime = new Date().getTime();
+        this.mediaRecorder?.resume();
+        this.recordingStateSubject.next(MediaRecordingState.RECORDING);
+    }
+    async stop(options = { cancel: false }) {
+        if (this.startTime) {
+            this.recordedChunkDurations.push(new Date().getTime() - this.startTime);
+            this.startTime = undefined;
+        }
+        let recording;
+        this.mediaRecorder?.stop();
+        try {
+            if (!options.cancel &&
+                this.recordingStateSubject.value !== MediaRecordingState.ERROR) {
+                recording = await new Promise((resolve, reject) => {
+                    this.recording$.subscribe((r) => {
+                        if (r) {
+                            resolve(r);
+                        }
+                    });
+                    this.recordingState$.subscribe((s) => {
+                        if (s === MediaRecordingState.ERROR) {
+                            reject(new Error(`Recording couldn't be created`));
+                        }
+                    });
+                });
+            }
+        }
+        catch {
+            this.notificationService.addTemporaryNotification('streamChat.An error has occurred during recording');
+        }
+        finally {
+            this.recordedChunkDurations = [];
+            this.startTime = undefined;
+            this.mediaRecorder?.removeEventListener('dataavailable', this.handleDataavailableEvent);
+            this.mediaRecorder?.removeEventListener('error', this.handleErrorEvent);
+            if (this.mediaRecorder?.stream?.active) {
+                this.mediaRecorder?.stream?.getTracks().forEach((track) => {
+                    track.stop();
+                    this.mediaRecorder?.stream?.removeTrack(track);
+                });
+                this.mediaRecorder = undefined;
+            }
+            this.recordingStateSubject.next(MediaRecordingState.STOPPED);
+        }
+        return recording;
+    }
+    logError(error) {
+        this.chatService.chatClient?.logger('error', error.message, {
+            error: error,
+            tag: ['MediaRecorder'],
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media-recorder.js","sourceRoot":"","sources":["../../../../../projects/stream-chat-angular/src/lib/voice-recorder/media-recorder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable } from 'rxjs';\nimport {\n  createFileFromBlobs,\n  createUriFromBlob,\n  getExtensionFromMimeType,\n} from '../file-utils';\nimport { NotificationService } from '../notification.service';\nimport { ChatClientService } from '../chat-client.service';\nimport fixWebmDuration from 'fix-webm-duration';\nimport { TranscoderService } from './transcoder.service';\nimport { MediaRecording } from '../types';\n\nexport type MediaRecorderConfig = Omit<MediaRecorderOptions, 'mimeType'> &\n  Required<Pick<MediaRecorderOptions, 'mimeType'>>;\n\nexport enum MediaRecordingState {\n  PAUSED = 'paused',\n  RECORDING = 'recording',\n  STOPPED = 'stopped',\n  ERROR = 'error',\n}\n\nexport type MediaRecordingTitleOptions = {\n  mimeType: string;\n};\n\nexport abstract class MultimediaRecorder<T = null> {\n  abstract config: MediaRecorderConfig;\n  customGenerateRecordingTitle:\n    | ((options: MediaRecordingTitleOptions) => string)\n    | undefined;\n  recordingState$: Observable<MediaRecordingState>;\n  recording$: Observable<(MediaRecording & T) | undefined>;\n\n  protected recordingSubject = new BehaviorSubject<\n    (MediaRecording & T) | undefined\n  >(undefined);\n\n  protected mediaRecorder: MediaRecorder | undefined;\n  protected startTime: number | undefined;\n  protected recordedChunkDurations: number[] = [];\n  private recordingStateSubject = new BehaviorSubject<MediaRecordingState>(\n    MediaRecordingState.STOPPED\n  );\n\n  constructor(\n    protected notificationService: NotificationService,\n    protected chatService: ChatClientService,\n    private transcoder: TranscoderService\n  ) {\n    this.recording$ = this.recordingSubject.asObservable();\n    this.recordingState$ = this.recordingStateSubject.asObservable();\n  }\n\n  get durationMs() {\n    return (\n      this.recordedChunkDurations.reduce((acc, val) => acc + val, 0) +\n      (this.startTime ? Date.now() - this.startTime : 0)\n    );\n  }\n\n  get mediaType() {\n    return this.config.mimeType.split('/')?.[0] || 'unknown';\n  }\n\n  get isRecording() {\n    return (\n      this.recordingStateSubject.value === MediaRecordingState.RECORDING ||\n      this.recordingStateSubject.value === MediaRecordingState.PAUSED\n    );\n  }\n\n  generateRecordingTitle = (mimeType: string) => {\n    if (this.customGenerateRecordingTitle) {\n      return this.customGenerateRecordingTitle({ mimeType });\n    } else {\n      return `${\n        this.mediaType\n      }_recording_${new Date().toISOString()}.${getExtensionFromMimeType(\n        mimeType\n      )}`; // extension needed so that desktop Safari can play the asset\n    }\n  };\n\n  async makeRecording(blob: Blob) {\n    const { mimeType } = this.config;\n    try {\n      if (mimeType.includes('webm')) {\n        // The browser does not include duration metadata with the recorded blob\n        blob = await fixWebmDuration(blob, this.durationMs, {\n          logger: () => null, // prevents polluting the browser console\n        });\n      }\n      blob = await this.transcoder.transcode(blob);\n\n      if (!blob) return;\n\n      const file = createFileFromBlobs({\n        blobsArray: [blob],\n        fileName: this.generateRecordingTitle(blob.type),\n        mimeType: blob.type,\n      });\n      const previewUrl = await createUriFromBlob(file);\n\n      const extraData = this.enrichWithExtraData();\n      this.recordingSubject.next({\n        recording: file,\n        duration: this.durationMs / 1000,\n        asset_url: previewUrl,\n        mime_type: mimeType,\n        ...extraData,\n      });\n      return file;\n    } catch (error) {\n      this.logError(error as Error);\n      this.recordingStateSubject.next(MediaRecordingState.ERROR);\n      return undefined;\n    }\n  }\n\n  handleErrorEvent = (e: Event) => {\n    /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */\n    this.logError((e as ErrorEvent).error);\n    this.recordingStateSubject.next(MediaRecordingState.ERROR);\n    this.notificationService.addTemporaryNotification(\n      'streamChat.An error has occurred during recording'\n    );\n    void this.stop({ cancel: true });\n  };\n\n  handleDataavailableEvent = (e: BlobEvent) => {\n    if (!e.data.size) return;\n    void this.makeRecording(e.data);\n  };\n\n  get recordingState() {\n    return this.recordingStateSubject.value;\n  }\n\n  async start() {\n    if (\n      [MediaRecordingState.RECORDING, MediaRecordingState.PAUSED].includes(\n        this.recordingStateSubject.value\n      )\n    ) {\n      return;\n    }\n\n    this.recordingSubject.next(undefined);\n\n    // account for requirement on iOS as per this bug report: https://bugs.webkit.org/show_bug.cgi?id=252303\n    if (!navigator.mediaDevices) {\n      console.warn(\n        `[Stream Chat] Media devices API missing, it's possible your app is not served from a secure context (https://developer.mozilla.org/en-US/docs/Web/Security/Secure_Contexts)`\n      );\n      const error = new Error('Media recording is not supported');\n      this.logError(error);\n      this.recordingStateSubject.next(MediaRecordingState.ERROR);\n      this.notificationService.addTemporaryNotification(\n        `streamChat.Media recording not supported`\n      );\n      return;\n    }\n\n    try {\n      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });\n      this.mediaRecorder = new MediaRecorder(stream, this.config);\n\n      this.mediaRecorder.addEventListener(\n        'dataavailable',\n        this.handleDataavailableEvent\n      );\n      this.mediaRecorder.addEventListener('error', this.handleErrorEvent);\n\n      this.startTime = new Date().getTime();\n      this.mediaRecorder.start();\n\n      this.recordingStateSubject.next(MediaRecordingState.RECORDING);\n    } catch (error) {\n      this.logError(error as Error);\n      void this.stop({ cancel: true });\n      this.recordingStateSubject.next(MediaRecordingState.ERROR);\n      const isNotAllowed = (error as Error).name?.includes('NotAllowedError');\n      this.notificationService.addTemporaryNotification(\n        isNotAllowed\n          ? `streamChat.Please grant permission to use microhpone`\n          : `streamChat.Error starting recording`\n      );\n    }\n  }\n\n  pause() {\n    if (this.recordingStateSubject.value !== MediaRecordingState.RECORDING)\n      return;\n    if (this.startTime) {\n      this.recordedChunkDurations.push(new Date().getTime() - this.startTime);\n      this.startTime = undefined;\n    }\n    this.mediaRecorder?.pause();\n    this.recordingStateSubject.next(MediaRecordingState.PAUSED);\n  }\n\n  resume() {\n    if (this.recordingStateSubject.value !== MediaRecordingState.PAUSED) return;\n    this.startTime = new Date().getTime();\n    this.mediaRecorder?.resume();\n    this.recordingStateSubject.next(MediaRecordingState.RECORDING);\n  }\n\n  async stop(options: { cancel: boolean } = { cancel: false }) {\n    if (this.startTime) {\n      this.recordedChunkDurations.push(new Date().getTime() - this.startTime);\n      this.startTime = undefined;\n    }\n    let recording!: MediaRecording & T;\n    this.mediaRecorder?.stop();\n    try {\n      if (\n        !options.cancel &&\n        this.recordingStateSubject.value !== MediaRecordingState.ERROR\n      ) {\n        recording = await new Promise((resolve, reject) => {\n          this.recording$.subscribe((r) => {\n            if (r) {\n              resolve(r);\n            }\n          });\n          this.recordingState$.subscribe((s) => {\n            if (s === MediaRecordingState.ERROR) {\n              reject(new Error(`Recording couldn't be created`));\n            }\n          });\n        });\n      }\n    } catch {\n      this.notificationService.addTemporaryNotification(\n        'streamChat.An error has occurred during recording'\n      );\n    } finally {\n      this.recordedChunkDurations = [];\n      this.startTime = undefined;\n\n      this.mediaRecorder?.removeEventListener(\n        'dataavailable',\n        this.handleDataavailableEvent\n      );\n      this.mediaRecorder?.removeEventListener('error', this.handleErrorEvent);\n      if (this.mediaRecorder?.stream?.active) {\n        this.mediaRecorder?.stream?.getTracks().forEach((track) => {\n          track.stop();\n          this.mediaRecorder?.stream?.removeTrack(track);\n        });\n        this.mediaRecorder = undefined;\n      }\n\n      this.recordingStateSubject.next(MediaRecordingState.STOPPED);\n    }\n\n    return recording;\n  }\n\n  protected abstract enrichWithExtraData(): T;\n\n  protected logError(error: Error) {\n    this.chatService.chatClient?.logger('error', error.message, {\n      error: error,\n      tag: ['MediaRecorder'],\n    });\n  }\n}\n"]}

package/esm2020/lib/voice-recorder/mp3-transcoder.mjs

@@ -0,0 +1,61 @@
+const ENCODING_BIT_RATE = 128; // kbps;
+const COUNT_SAMPLES_PER_ENCODED_BLOCK = 1152;
+const SAMPLE_RATE = 16000;
+const readFileAsArrayBuffer = (blob) => new Promise((resolve, reject) => {
+    const blobReader = new FileReader();
+    blobReader.onload = () => {
+        resolve(blobReader.result);
+    };
+    blobReader.onerror = () => {
+        reject(blobReader.error);
+    };
+    blobReader.readAsArrayBuffer(blob);
+});
+const toAudioBuffer = async (blob) => {
+    const audioCtx = new AudioContext();
+    const arrayBuffer = await readFileAsArrayBuffer(blob);
+    const decodedData = await audioCtx.decodeAudioData(arrayBuffer);
+    if (audioCtx.state !== 'closed')
+        await audioCtx.close();
+    return decodedData;
+};
+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();
+};
+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
+        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;
+};
+const splitDataByChannel = (audioBuffer) => Array.from({ length: audioBuffer.numberOfChannels }, (_, i) => audioBuffer.getChannelData(i)).map(float32ArrayToInt16Array);
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
+export async function encodeWebmToMp3(blob, lameJs) {
+    const audioBuffer = await renderAudio(await toAudioBuffer(blob), SAMPLE_RATE);
+    const channelCount = audioBuffer.numberOfChannels;
+    const dataByChannel = splitDataByChannel(audioBuffer);
+    const mp3Encoder = new lameJs.Mp3Encoder(channelCount, SAMPLE_RATE, 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' });
+}
+/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mp3-transcoder.js","sourceRoot":"","sources":["../../../../../projects/stream-chat-angular/src/lib/voice-recorder/mp3-transcoder.ts"],"names":[],"mappings":"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","sourcesContent":["const ENCODING_BIT_RATE = 128; // kbps;\nconst COUNT_SAMPLES_PER_ENCODED_BLOCK = 1152;\nconst SAMPLE_RATE = 16000;\n\nconst readFileAsArrayBuffer = (blob: Blob): Promise<ArrayBuffer> =>\n  new Promise((resolve, reject) => {\n    const blobReader = new FileReader();\n    blobReader.onload = () => {\n      resolve(blobReader.result as ArrayBuffer);\n    };\n\n    blobReader.onerror = () => {\n      reject(blobReader.error);\n    };\n\n    blobReader.readAsArrayBuffer(blob);\n  });\n\nconst toAudioBuffer = async (blob: Blob) => {\n  const audioCtx = new AudioContext();\n\n  const arrayBuffer = await readFileAsArrayBuffer(blob);\n  const decodedData = await audioCtx.decodeAudioData(arrayBuffer);\n  if (audioCtx.state !== 'closed') await audioCtx.close();\n  return decodedData;\n};\n\nconst renderAudio = async (audioBuffer: AudioBuffer, sampleRate: number) => {\n  const offlineAudioCtx = new OfflineAudioContext(\n    audioBuffer.numberOfChannels,\n    audioBuffer.duration * sampleRate,\n    sampleRate\n  );\n  const source = offlineAudioCtx.createBufferSource();\n  source.buffer = audioBuffer;\n  source.connect(offlineAudioCtx.destination);\n  source.start();\n\n  return await offlineAudioCtx.startRendering();\n};\n\nconst float32ArrayToInt16Array = (float32Arr: Float32Array) => {\n  const int16Arr = new Int16Array(float32Arr.length);\n  for (let i = 0; i < float32Arr.length; i++) {\n    const float32Value = float32Arr[i];\n    // Clamp the float value between -1 and 1\n    const clampedValue = Math.max(-1, Math.min(1, float32Value));\n    // Convert the float value to a signed 16-bit integer\n    int16Arr[i] = Math.round(clampedValue * 32767);\n  }\n  return int16Arr;\n};\n\nconst splitDataByChannel = (audioBuffer: AudioBuffer) =>\n  Array.from({ length: audioBuffer.numberOfChannels }, (_, i) =>\n    audioBuffer.getChannelData(i)\n  ).map(float32ArrayToInt16Array);\n\n/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */\nexport async function encodeWebmToMp3(blob: Blob, lameJs: any) {\n  const audioBuffer = await renderAudio(await toAudioBuffer(blob), SAMPLE_RATE);\n  const channelCount = audioBuffer.numberOfChannels;\n  const dataByChannel = splitDataByChannel(audioBuffer);\n  const mp3Encoder = new lameJs.Mp3Encoder(\n    channelCount,\n    SAMPLE_RATE,\n    ENCODING_BIT_RATE\n  );\n\n  const dataBuffer: Int8Array[] = [];\n  let remaining = dataByChannel[0].length;\n  for (\n    let i = 0;\n    remaining >= COUNT_SAMPLES_PER_ENCODED_BLOCK;\n    i += COUNT_SAMPLES_PER_ENCODED_BLOCK\n  ) {\n    const [leftChannelBlock, rightChannelBlock] = dataByChannel.map((channel) =>\n      channel.subarray(i, i + COUNT_SAMPLES_PER_ENCODED_BLOCK)\n    );\n    dataBuffer.push(\n      new Int8Array(\n        mp3Encoder.encodeBuffer(leftChannelBlock, rightChannelBlock)\n      )\n    );\n    remaining -= COUNT_SAMPLES_PER_ENCODED_BLOCK;\n  }\n\n  const lastBlock = mp3Encoder.flush();\n  if (lastBlock.length) dataBuffer.push(new Int8Array(lastBlock));\n  return new Blob(dataBuffer, { type: 'audio/mp3;sbu_type=voice' });\n}\n/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */\n"]}

package/esm2020/lib/voice-recorder/transcoder.service.mjs

@@ -0,0 +1,121 @@
+import { Injectable, NgModule } from '@angular/core';
+import { readBlobAsArrayBuffer } from '../file-utils';
+import * as i0 from "@angular/core";
+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 },
+    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
+};
+/**
+ * The `TranscoderService` is used to transcibe audio recording to a format that's supported by all major browsers. The SDK uses this to create voice messages.
+ *
+ * If you want to use your own transcoder you can provide a `customTranscoder`.
+ */
+export class TranscoderService {
+    constructor() {
+        this.config = {
+            sampleRate: 16000,
+        };
+        this.splitDataByChannel = (audioBuffer) => Array.from({ length: audioBuffer.numberOfChannels }, (_, i) => audioBuffer.getChannelData(i));
+    }
+    /**
+     * The default transcoder will leave audio/mp4 files as is, and transcode webm files to wav. If you want to customize this, you can provide your own transcoder using the `customTranscoder` field
+     * @param blob
+     * @returns the transcoded file
+     */
+    async transcode(blob) {
+        if (this.customTranscoder) {
+            return this.customTranscoder(blob);
+        }
+        if (blob.type.includes('audio/mp4')) {
+            return blob;
+        }
+        const audioBuffer = await this.renderAudio(await this.toAudioBuffer(blob), this.config.sampleRate);
+        const numberOfSamples = audioBuffer.duration * this.config.sampleRate;
+        const fileSizeBytes = numberOfSamples * audioBuffer.numberOfChannels * BYTES_PER_SAMPLE +
+            WAV_HEADER_LENGTH_BYTES;
+        const arrayBuffer = new ArrayBuffer(fileSizeBytes);
+        this.writeWavHeader({
+            arrayBuffer,
+            channelCount: audioBuffer.numberOfChannels,
+            sampleRate: this.config.sampleRate,
+        });
+        this.writeWavAudioData({
+            arrayBuffer,
+            dataByChannel: this.splitDataByChannel(audioBuffer),
+        });
+        return new Blob([arrayBuffer], { type: 'audio/wav' });
+    }
+    async renderAudio(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();
+    }
+    async toAudioBuffer(blob) {
+        const audioCtx = new AudioContext();
+        const arrayBuffer = await readBlobAsArrayBuffer(blob);
+        const decodedData = await audioCtx.decodeAudioData(arrayBuffer);
+        if (audioCtx.state !== 'closed')
+            await audioCtx.close();
+        return decodedData;
+    }
+    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;
+            });
+        });
+    }
+    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.
+         */
+        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"
+        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);
+    }
+}
+TranscoderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: TranscoderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TranscoderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: TranscoderService, providedIn: NgModule });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: TranscoderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: NgModule }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transcoder.service.js","sourceRoot":"","sources":["../../../../../projects/stream-chat-angular/src/lib/voice-recorder/transcoder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgModule } from '@angular/core';\nimport { readBlobAsArrayBuffer } from '../file-utils';\n\nexport type TranscoderConfig = {\n  sampleRate: number;\n};\n\nexport type TranscodeParams = TranscoderConfig & {\n  blob: Blob;\n};\n\nconst WAV_HEADER_LENGTH_BYTES = 44 as const;\nconst BYTES_PER_SAMPLE = 2 as const;\nconst RIFF_FILE_MAX_BYTES = 4294967295 as const;\n\nconst HEADER = {\n  AUDIO_FORMAT: { offset: 20, value: 1 }, // PCM = 1\n  BITS_PER_SAMPLE: { offset: 34, value: BYTES_PER_SAMPLE * 8 }, // 16 bits encoding\n  BLOCK_ALIGN: { offset: 32 },\n  BYTE_RATE: { offset: 28 },\n  CHANNEL_COUNT: { offset: 22 }, // 1 - mono, 2 - stereo\n  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\n  CHUNK_SIZE: { offset: 4 },\n  FILE_FORMAT: { offset: 8, value: 0x57415645 }, // hex representation of string \"WAVE\"\n  SAMPLE_RATE: { offset: 24 },\n  SUBCHUNK1_ID: { offset: 12, value: 0x666d7420 }, // hex representation of string \"fmt \" - identifies the start of \"format\" section of the header\n  SUBCHUNK1_SIZE: { offset: 16, value: 16 }, // Subchunk1 Size without SUBCHUNK1_ID and SUBCHUNK1_SIZE fields\n  SUBCHUNK2_ID: { offset: 36, value: 0x64617461 }, // hex representation of string \"data\" - identifies the start of actual audio data section\n  SUBCHUNK2_SIZE: { offset: 40 }, // actual audio data size\n} as const;\n\ntype WriteWaveHeaderParams = {\n  arrayBuffer: ArrayBuffer;\n  // 1 - mono, 2 - stereo\n  channelCount: number;\n  // Number of samples per second, e.g. 44100Hz\n  sampleRate: number;\n};\n\ntype WriteAudioDataParams = {\n  arrayBuffer: ArrayBuffer;\n  dataByChannel: Float32Array[];\n};\n\n/**\n * The `TranscoderService` is used to transcibe audio recording to a format that's supported by all major browsers. The SDK uses this to create voice messages.\n *\n * If you want to use your own transcoder you can provide a `customTranscoder`.\n */\n@Injectable({ providedIn: NgModule })\nexport class TranscoderService {\n  config: TranscoderConfig = {\n    sampleRate: 16000,\n  };\n  customTranscoder?: (blob: Blob) => Blob | Promise<Blob>;\n  constructor() {}\n\n  /**\n   * The default transcoder will leave audio/mp4 files as is, and transcode webm files to wav. If you want to customize this, you can provide your own transcoder using the `customTranscoder` field\n   * @param blob\n   * @returns the transcoded file\n   */\n  async transcode(blob: Blob) {\n    if (this.customTranscoder) {\n      return this.customTranscoder(blob);\n    }\n    if (blob.type.includes('audio/mp4')) {\n      return blob;\n    }\n    const audioBuffer = await this.renderAudio(\n      await this.toAudioBuffer(blob),\n      this.config.sampleRate\n    );\n    const numberOfSamples = audioBuffer.duration * this.config.sampleRate;\n    const fileSizeBytes =\n      numberOfSamples * audioBuffer.numberOfChannels * BYTES_PER_SAMPLE +\n      WAV_HEADER_LENGTH_BYTES;\n\n    const arrayBuffer = new ArrayBuffer(fileSizeBytes);\n    this.writeWavHeader({\n      arrayBuffer,\n      channelCount: audioBuffer.numberOfChannels,\n      sampleRate: this.config.sampleRate,\n    });\n    this.writeWavAudioData({\n      arrayBuffer,\n      dataByChannel: this.splitDataByChannel(audioBuffer),\n    });\n    return new Blob([arrayBuffer], { type: 'audio/wav' });\n  }\n\n  protected async renderAudio(audioBuffer: AudioBuffer, sampleRate: number) {\n    const offlineAudioCtx = new OfflineAudioContext(\n      audioBuffer.numberOfChannels,\n      audioBuffer.duration * sampleRate,\n      sampleRate\n    );\n    const source = offlineAudioCtx.createBufferSource();\n    source.buffer = audioBuffer;\n    source.connect(offlineAudioCtx.destination);\n    source.start();\n\n    return await offlineAudioCtx.startRendering();\n  }\n\n  protected async toAudioBuffer(blob: Blob) {\n    const audioCtx = new AudioContext();\n\n    const arrayBuffer = await readBlobAsArrayBuffer(blob);\n    const decodedData = await audioCtx.decodeAudioData(arrayBuffer);\n    if (audioCtx.state !== 'closed') await audioCtx.close();\n    return decodedData;\n  }\n\n  protected writeWavAudioData({\n    arrayBuffer,\n    dataByChannel,\n  }: WriteAudioDataParams) {\n    const dataView = new DataView(arrayBuffer);\n    const channelCount = dataByChannel.length;\n\n    dataByChannel.forEach((channelData, channelIndex) => {\n      let writeOffset = WAV_HEADER_LENGTH_BYTES + channelCount * channelIndex;\n\n      channelData.forEach((float32Value) => {\n        dataView.setInt16(\n          writeOffset,\n          float32Value < 0\n            ? Math.max(-1, float32Value) * 32768\n            : Math.min(1, float32Value) * 32767,\n          true\n        );\n        writeOffset += channelCount * BYTES_PER_SAMPLE;\n      });\n    });\n  }\n\n  protected writeWavHeader({\n    arrayBuffer,\n    channelCount,\n    sampleRate,\n  }: WriteWaveHeaderParams) {\n    const byteRate = sampleRate * channelCount * BYTES_PER_SAMPLE; // bytes/sec\n    const blockAlign = channelCount * BYTES_PER_SAMPLE;\n\n    const dataView = new DataView(arrayBuffer);\n    /*\n     * 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\n     * data chunk.\n     */\n    const dataChunkSize = Math.min(\n      dataView.byteLength - WAV_HEADER_LENGTH_BYTES,\n      RIFF_FILE_MAX_BYTES - WAV_HEADER_LENGTH_BYTES\n    );\n\n    dataView.setUint32(HEADER.CHUNK_ID.offset, HEADER.CHUNK_ID.value); // \"RIFF\"\n    dataView.setUint32(\n      HEADER.CHUNK_SIZE.offset,\n      arrayBuffer.byteLength - 8,\n      true\n    ); // adjustment for the first two headers - chunk id + file size\n    dataView.setUint32(HEADER.FILE_FORMAT.offset, HEADER.FILE_FORMAT.value); // \"WAVE\"\n\n    dataView.setUint32(HEADER.SUBCHUNK1_ID.offset, HEADER.SUBCHUNK1_ID.value); // \"fmt \"\n    dataView.setUint32(\n      HEADER.SUBCHUNK1_SIZE.offset,\n      HEADER.SUBCHUNK1_SIZE.value,\n      true\n    );\n    dataView.setUint16(\n      HEADER.AUDIO_FORMAT.offset,\n      HEADER.AUDIO_FORMAT.value,\n      true\n    );\n    dataView.setUint16(HEADER.CHANNEL_COUNT.offset, channelCount, true);\n    dataView.setUint32(HEADER.SAMPLE_RATE.offset, sampleRate, true);\n    dataView.setUint32(HEADER.BYTE_RATE.offset, byteRate, true);\n    dataView.setUint16(HEADER.BLOCK_ALIGN.offset, blockAlign, true);\n    dataView.setUint16(\n      HEADER.BITS_PER_SAMPLE.offset,\n      HEADER.BITS_PER_SAMPLE.value,\n      true\n    );\n\n    dataView.setUint32(HEADER.SUBCHUNK2_ID.offset, HEADER.SUBCHUNK2_ID.value); // \"data\"\n    dataView.setUint32(HEADER.SUBCHUNK2_SIZE.offset, dataChunkSize, true);\n  }\n\n  protected splitDataByChannel = (audioBuffer: AudioBuffer) =>\n    Array.from({ length: audioBuffer.numberOfChannels }, (_, i) =>\n      audioBuffer.getChannelData(i)\n    );\n}\n"]}

package/esm2020/lib/voice-recorder/voice-recorder-wavebar/voice-recorder-wavebar.component.mjs

@@ -0,0 +1,35 @@
+import { Component } from '@angular/core';
+import { formatDuration } from '../../format-duration';
+import * as i0 from "@angular/core";
+import * as i1 from "../amplitude-recorder.service";
+import * as i2 from "../audio-recorder.service";
+import * as i3 from "@angular/common";
+/**
+ * The `VoiceRecorderWavebarComponent` displays the amplitudes of the recording while the recoding is in progress
+ */
+export class VoiceRecorderWavebarComponent {
+    constructor(amplitudeRecorder, audioRecorder) {
+        this.amplitudeRecorder = amplitudeRecorder;
+        this.audioRecorder = audioRecorder;
+        this.isLongerThanOneHour = false;
+        this.amplitudes$ = this.amplitudeRecorder.amplitudes$;
+        this.formattedDuration = formatDuration(this.audioRecorder.durationMs / 1000);
+        this.durationComputeInterval = setInterval(() => {
+            this.isLongerThanOneHour = this.audioRecorder.durationMs / 1000 > 3600;
+            this.formattedDuration = formatDuration(this.audioRecorder.durationMs / 1000);
+        }, 1000);
+    }
+    trackByIndex(i) {
+        return i;
+    }
+    ngOnDestroy() {
+        clearInterval(this.durationComputeInterval);
+    }
+}
+VoiceRecorderWavebarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: VoiceRecorderWavebarComponent, deps: [{ token: i1.AmplitudeRecorderService }, { token: i2.AudioRecorderService }], target: i0.ɵɵFactoryTarget.Component });
+VoiceRecorderWavebarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: VoiceRecorderWavebarComponent, selector: "stream-voice-recorder-wavebar", ngImport: i0, template: "<div\n  class=\"str-chat__recording-timer\"\n  [class.str-chat__recording-timer--hours]=\"isLongerThanOneHour\"\n>\n  {{ formattedDuration }}\n</div>\n<div class=\"str-chat__waveform-box-container\">\n  <div class=\"str-chat__audio_recorder__waveform-box\">\n    <div\n      *ngFor=\"let amplitude of amplitudes$ | async; trackBy: trackByIndex\"\n      class=\"str-chat__wave-progress-bar__amplitude-bar\"\n      [style.--str-chat__wave-progress-bar__amplitude-bar-height]=\"\n        (amplitude ?? 0) * 100 + '%'\n      \"\n    ></div>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i3.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: VoiceRecorderWavebarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'stream-voice-recorder-wavebar', template: "<div\n  class=\"str-chat__recording-timer\"\n  [class.str-chat__recording-timer--hours]=\"isLongerThanOneHour\"\n>\n  {{ formattedDuration }}\n</div>\n<div class=\"str-chat__waveform-box-container\">\n  <div class=\"str-chat__audio_recorder__waveform-box\">\n    <div\n      *ngFor=\"let amplitude of amplitudes$ | async; trackBy: trackByIndex\"\n      class=\"str-chat__wave-progress-bar__amplitude-bar\"\n      [style.--str-chat__wave-progress-bar__amplitude-bar-height]=\"\n        (amplitude ?? 0) * 100 + '%'\n      \"\n    ></div>\n  </div>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.AmplitudeRecorderService }, { type: i2.AudioRecorderService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/voice-recorder/voice-recorder.component.mjs

@@ -0,0 +1,80 @@
+import { Component, Input, } from '@angular/core';
+import { MediaRecordingState } from './media-recorder';
+import * as i0 from "@angular/core";
+import * as i1 from "./audio-recorder.service";
+import * as i2 from "@angular/common";
+import * as i3 from "../voice-recording/voice-recording.component";
+import * as i4 from "../icon/icon-placeholder/icon-placeholder.component";
+import * as i5 from "../icon/loading-indicator/loading-indicator.component";
+import * as i6 from "./voice-recorder-wavebar/voice-recorder-wavebar.component";
+/**
+ * The `VoiceRecorderComponent` makes it possible to record audio, and then upload it as a voice recording attachment
+ */
+export class VoiceRecorderComponent {
+    constructor(recorder) {
+        this.recorder = recorder;
+        this.recordState = MediaRecordingState.STOPPED;
+        this.isLoading = false;
+        this.MediaRecordingState = MediaRecordingState;
+        this.subscriptions = [];
+    }
+    ngOnInit() {
+        this.subscriptions.push(this.recorder.recordingState$.subscribe((s) => {
+            this.recordState = s;
+            if (this.recordState === MediaRecordingState.ERROR) {
+                this.voiceRecorderService?.isRecorderVisible$.next(false);
+            }
+        }));
+    }
+    ngOnChanges(changes) {
+        if (changes.voiceRecorderService && this.voiceRecorderService) {
+            this.isVisibleSubscription =
+                this.voiceRecorderService.isRecorderVisible$.subscribe((isVisible) => {
+                    if (!isVisible) {
+                        this.recording = undefined;
+                        this.isLoading = false;
+                    }
+                });
+        }
+        else {
+            this.isVisibleSubscription?.unsubscribe();
+        }
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((s) => s.unsubscribe());
+    }
+    cancel() {
+        if (this.recording) {
+            this.recording = undefined;
+        }
+        else {
+            void this.recorder.stop({ cancel: true });
+        }
+        this.voiceRecorderService?.isRecorderVisible$.next(false);
+    }
+    async stop() {
+        this.recording = await this.recorder.stop();
+    }
+    pause() {
+        this.recorder.pause();
+    }
+    resume() {
+        this.recorder.resume();
+    }
+    uploadRecording() {
+        if (!this.recording) {
+            return;
+        }
+        this.isLoading = true;
+        this.voiceRecorderService?.recording$.next(this.recording);
+    }
+}
+VoiceRecorderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: VoiceRecorderComponent, deps: [{ token: i1.AudioRecorderService }], target: i0.ɵɵFactoryTarget.Component });
+VoiceRecorderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.0.4", type: VoiceRecorderComponent, selector: "stream-voice-recorder", inputs: { voiceRecorderService: "voiceRecorderService" }, providers: [], usesOnChanges: true, ngImport: i0, template: "<div\n  class=\"str-chat__audio_recorder-container\"\n  *ngIf=\"voiceRecorderService?.isRecorderVisible$ | async\"\n>\n  <div class=\"str-chat__audio_recorder\" data-testid=\"audio-recorder\">\n    <button\n      class=\"str-chat__audio_recorder__cancel-button\"\n      data-testid=\"cancel-recording-audio-button\"\n      [disabled]=\"isLoading\"\n      (click)=\"cancel()\"\n      (keyup.enter)=\"cancel()\"\n    >\n      <stream-icon-placeholder icon=\"bin\"></stream-icon-placeholder>\n    </button>\n    <stream-voice-recorder-wavebar\n      *ngIf=\"\n        (recordState === MediaRecordingState.RECORDING ||\n          recordState === MediaRecordingState.PAUSED) &&\n        !recording\n      \"\n    ></stream-voice-recorder-wavebar>\n    <!-- eslint-disable @angular-eslint/template/no-any -->\n    <stream-voice-recording\n      [attachment]=\"$any(recording)\"\n      *ngIf=\"!!recording\"\n    ></stream-voice-recording>\n    <!-- eslint-enable @angular-eslint/template/no-any -->\n    <button\n      *ngIf=\"recordState === MediaRecordingState.PAUSED && !recording\"\n      class=\"str-chat__audio_recorder__resume-recording-button\"\n      (click)=\"resume()\"\n      (keyup.enter)=\"resume()\"\n    >\n      <stream-icon-placeholder icon=\"mic\"></stream-icon-placeholder>\n    </button>\n    <button\n      *ngIf=\"recordState === MediaRecordingState.RECORDING && !recording\"\n      class=\"str-chat__audio_recorder__pause-recording-button\"\n      data-testid=\"pause-recording-audio-button\"\n      (click)=\"pause()\"\n      (keyup.enter)=\"pause()\"\n    >\n      <stream-icon-placeholder icon=\"pause\"></stream-icon-placeholder>\n    </button>\n    <ng-container\n      *ngIf=\"recordState === MediaRecordingState.STOPPED; else stopButton\"\n    >\n      <button\n        class=\"str-chat__audio_recorder__complete-button\"\n        data-testid=\"audio-recorder-complete-button\"\n        [disabled]=\"!recording\"\n        (click)=\"uploadRecording()\"\n        (keyup.enter)=\"uploadRecording()\"\n      >\n        <stream-loading-indicator\n          *ngIf=\"isLoading; else sendIcon\"\n        ></stream-loading-indicator>\n        <ng-template #sendIcon>\n          <stream-icon-placeholder icon=\"send\"></stream-icon-placeholder>\n        </ng-template>\n      </button>\n    </ng-container>\n    <ng-template #stopButton>\n      <button\n        class=\"str-chat__audio_recorder__stop-button\"\n        data-testid=\"audio-recorder-stop-button\"\n        [disabled]=\"recordState === MediaRecordingState.STOPPED\"\n        (click)=\"stop()\"\n        (keyup.enter)=\"stop()\"\n      >\n        <stream-icon-placeholder icon=\"delivered\"></stream-icon-placeholder>\n      </button>\n    </ng-template>\n  </div>\n</div>\n", dependencies: [{ kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3.VoiceRecordingComponent, selector: "stream-voice-recording", inputs: ["attachment"] }, { kind: "component", type: i4.IconPlaceholderComponent, selector: "stream-icon-placeholder", inputs: ["icon"] }, { kind: "component", type: i5.LoadingIndicatorComponent, selector: "stream-loading-indicator" }, { kind: "component", type: i6.VoiceRecorderWavebarComponent, selector: "stream-voice-recorder-wavebar" }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: VoiceRecorderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'stream-voice-recorder', providers: [], template: "<div\n  class=\"str-chat__audio_recorder-container\"\n  *ngIf=\"voiceRecorderService?.isRecorderVisible$ | async\"\n>\n  <div class=\"str-chat__audio_recorder\" data-testid=\"audio-recorder\">\n    <button\n      class=\"str-chat__audio_recorder__cancel-button\"\n      data-testid=\"cancel-recording-audio-button\"\n      [disabled]=\"isLoading\"\n      (click)=\"cancel()\"\n      (keyup.enter)=\"cancel()\"\n    >\n      <stream-icon-placeholder icon=\"bin\"></stream-icon-placeholder>\n    </button>\n    <stream-voice-recorder-wavebar\n      *ngIf=\"\n        (recordState === MediaRecordingState.RECORDING ||\n          recordState === MediaRecordingState.PAUSED) &&\n        !recording\n      \"\n    ></stream-voice-recorder-wavebar>\n    <!-- eslint-disable @angular-eslint/template/no-any -->\n    <stream-voice-recording\n      [attachment]=\"$any(recording)\"\n      *ngIf=\"!!recording\"\n    ></stream-voice-recording>\n    <!-- eslint-enable @angular-eslint/template/no-any -->\n    <button\n      *ngIf=\"recordState === MediaRecordingState.PAUSED && !recording\"\n      class=\"str-chat__audio_recorder__resume-recording-button\"\n      (click)=\"resume()\"\n      (keyup.enter)=\"resume()\"\n    >\n      <stream-icon-placeholder icon=\"mic\"></stream-icon-placeholder>\n    </button>\n    <button\n      *ngIf=\"recordState === MediaRecordingState.RECORDING && !recording\"\n      class=\"str-chat__audio_recorder__pause-recording-button\"\n      data-testid=\"pause-recording-audio-button\"\n      (click)=\"pause()\"\n      (keyup.enter)=\"pause()\"\n    >\n      <stream-icon-placeholder icon=\"pause\"></stream-icon-placeholder>\n    </button>\n    <ng-container\n      *ngIf=\"recordState === MediaRecordingState.STOPPED; else stopButton\"\n    >\n      <button\n        class=\"str-chat__audio_recorder__complete-button\"\n        data-testid=\"audio-recorder-complete-button\"\n        [disabled]=\"!recording\"\n        (click)=\"uploadRecording()\"\n        (keyup.enter)=\"uploadRecording()\"\n      >\n        <stream-loading-indicator\n          *ngIf=\"isLoading; else sendIcon\"\n        ></stream-loading-indicator>\n        <ng-template #sendIcon>\n          <stream-icon-placeholder icon=\"send\"></stream-icon-placeholder>\n        </ng-template>\n      </button>\n    </ng-container>\n    <ng-template #stopButton>\n      <button\n        class=\"str-chat__audio_recorder__stop-button\"\n        data-testid=\"audio-recorder-stop-button\"\n        [disabled]=\"recordState === MediaRecordingState.STOPPED\"\n        (click)=\"stop()\"\n        (keyup.enter)=\"stop()\"\n      >\n        <stream-icon-placeholder icon=\"delivered\"></stream-icon-placeholder>\n      </button>\n    </ng-template>\n  </div>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.AudioRecorderService }]; }, propDecorators: { voiceRecorderService: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"voice-recorder.component.js","sourceRoot":"","sources":["../../../../../projects/stream-chat-angular/src/lib/voice-recorder/voice-recorder.component.ts","../../../../../projects/stream-chat-angular/src/lib/voice-recorder/voice-recorder.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,KAAK,GAKN,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;;;;;;;;AAKvD;;GAEG;AAOH,MAAM,OAAO,sBAAsB;IASjC,YAA4B,QAA8B;QAA9B,aAAQ,GAAR,QAAQ,CAAsB;QAP1D,gBAAW,GAAwB,mBAAmB,CAAC,OAAO,CAAC;QAC/D,cAAS,GAAG,KAAK,CAAC;QAET,wBAAmB,GAAG,mBAAmB,CAAC;QAC3C,kBAAa,GAAmB,EAAE,CAAC;IAGkB,CAAC;IAE9D,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE;YAC5C,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;YACrB,IAAI,IAAI,CAAC,WAAW,KAAK,mBAAmB,CAAC,KAAK,EAAE;gBAClD,IAAI,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAC3D;QACH,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,OAAsB;QAChC,IAAI,OAAO,CAAC,oBAAoB,IAAI,IAAI,CAAC,oBAAoB,EAAE;YAC7D,IAAI,CAAC,qBAAqB;gBACxB,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;oBACnE,IAAI,CAAC,SAAS,EAAE;wBACd,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;wBAC3B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;qBACxB;gBACH,CAAC,CAAC,CAAC;SACN;aAAM;YACL,IAAI,CAAC,qBAAqB,EAAE,WAAW,EAAE,CAAC;SAC3C;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,MAAM;QACJ,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;SAC5B;aAAM;YACL,KAAK,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;SAC3C;QACD,IAAI,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5D,CAAC;IAED,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,SAAS,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC9C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IAED,MAAM;QACJ,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IACzB,CAAC;IAED,eAAe;QACb,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,OAAO;SACR;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAC7D,CAAC;;mHAnEU,sBAAsB;uGAAtB,sBAAsB,0GAFtB,EAAE,+CCrBf,ksFA2EA;2FDpDa,sBAAsB;kBANlC,SAAS;+BACE,uBAAuB,aAGtB,EAAE;2GAGJ,oBAAoB;sBAA5B,KAAK","sourcesContent":["import {\n  Component,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n} from '@angular/core';\nimport { AudioRecorderService } from './audio-recorder.service';\nimport { MediaRecordingState } from './media-recorder';\nimport { Subscription } from 'rxjs';\nimport { AudioRecording } from '../types';\nimport { VoiceRecorderService } from '../message-input/voice-recorder.service';\n\n/**\n * The `VoiceRecorderComponent` makes it possible to record audio, and then upload it as a voice recording attachment\n */\n@Component({\n  selector: 'stream-voice-recorder',\n  templateUrl: './voice-recorder.component.html',\n  styles: [],\n  providers: [],\n})\nexport class VoiceRecorderComponent implements OnInit, OnDestroy, OnChanges {\n  @Input() voiceRecorderService?: VoiceRecorderService;\n  recordState: MediaRecordingState = MediaRecordingState.STOPPED;\n  isLoading = false;\n  recording?: AudioRecording;\n  readonly MediaRecordingState = MediaRecordingState;\n  private subscriptions: Subscription[] = [];\n  private isVisibleSubscription?: Subscription;\n\n  constructor(public readonly recorder: AudioRecorderService) {}\n\n  ngOnInit(): void {\n    this.subscriptions.push(\n      this.recorder.recordingState$.subscribe((s) => {\n        this.recordState = s;\n        if (this.recordState === MediaRecordingState.ERROR) {\n          this.voiceRecorderService?.isRecorderVisible$.next(false);\n        }\n      })\n    );\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.voiceRecorderService && this.voiceRecorderService) {\n      this.isVisibleSubscription =\n        this.voiceRecorderService.isRecorderVisible$.subscribe((isVisible) => {\n          if (!isVisible) {\n            this.recording = undefined;\n            this.isLoading = false;\n          }\n        });\n    } else {\n      this.isVisibleSubscription?.unsubscribe();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.subscriptions.forEach((s) => s.unsubscribe());\n  }\n\n  cancel() {\n    if (this.recording) {\n      this.recording = undefined;\n    } else {\n      void this.recorder.stop({ cancel: true });\n    }\n    this.voiceRecorderService?.isRecorderVisible$.next(false);\n  }\n\n  async stop() {\n    this.recording = await this.recorder.stop();\n  }\n\n  pause() {\n    this.recorder.pause();\n  }\n\n  resume() {\n    this.recorder.resume();\n  }\n\n  uploadRecording() {\n    if (!this.recording) {\n      return;\n    }\n    this.isLoading = true;\n    this.voiceRecorderService?.recording$.next(this.recording);\n  }\n}\n","<div\n  class=\"str-chat__audio_recorder-container\"\n  *ngIf=\"voiceRecorderService?.isRecorderVisible$ | async\"\n>\n  <div class=\"str-chat__audio_recorder\" data-testid=\"audio-recorder\">\n    <button\n      class=\"str-chat__audio_recorder__cancel-button\"\n      data-testid=\"cancel-recording-audio-button\"\n      [disabled]=\"isLoading\"\n      (click)=\"cancel()\"\n      (keyup.enter)=\"cancel()\"\n    >\n      <stream-icon-placeholder icon=\"bin\"></stream-icon-placeholder>\n    </button>\n    <stream-voice-recorder-wavebar\n      *ngIf=\"\n        (recordState === MediaRecordingState.RECORDING ||\n          recordState === MediaRecordingState.PAUSED) &&\n        !recording\n      \"\n    ></stream-voice-recorder-wavebar>\n    <!-- eslint-disable @angular-eslint/template/no-any -->\n    <stream-voice-recording\n      [attachment]=\"$any(recording)\"\n      *ngIf=\"!!recording\"\n    ></stream-voice-recording>\n    <!-- eslint-enable @angular-eslint/template/no-any -->\n    <button\n      *ngIf=\"recordState === MediaRecordingState.PAUSED && !recording\"\n      class=\"str-chat__audio_recorder__resume-recording-button\"\n      (click)=\"resume()\"\n      (keyup.enter)=\"resume()\"\n    >\n      <stream-icon-placeholder icon=\"mic\"></stream-icon-placeholder>\n    </button>\n    <button\n      *ngIf=\"recordState === MediaRecordingState.RECORDING && !recording\"\n      class=\"str-chat__audio_recorder__pause-recording-button\"\n      data-testid=\"pause-recording-audio-button\"\n      (click)=\"pause()\"\n      (keyup.enter)=\"pause()\"\n    >\n      <stream-icon-placeholder icon=\"pause\"></stream-icon-placeholder>\n    </button>\n    <ng-container\n      *ngIf=\"recordState === MediaRecordingState.STOPPED; else stopButton\"\n    >\n      <button\n        class=\"str-chat__audio_recorder__complete-button\"\n        data-testid=\"audio-recorder-complete-button\"\n        [disabled]=\"!recording\"\n        (click)=\"uploadRecording()\"\n        (keyup.enter)=\"uploadRecording()\"\n      >\n        <stream-loading-indicator\n          *ngIf=\"isLoading; else sendIcon\"\n        ></stream-loading-indicator>\n        <ng-template #sendIcon>\n          <stream-icon-placeholder icon=\"send\"></stream-icon-placeholder>\n        </ng-template>\n      </button>\n    </ng-container>\n    <ng-template #stopButton>\n      <button\n        class=\"str-chat__audio_recorder__stop-button\"\n        data-testid=\"audio-recorder-stop-button\"\n        [disabled]=\"recordState === MediaRecordingState.STOPPED\"\n        (click)=\"stop()\"\n        (keyup.enter)=\"stop()\"\n      >\n        <stream-icon-placeholder icon=\"delivered\"></stream-icon-placeholder>\n      </button>\n    </ng-template>\n  </div>\n</div>\n"]}