@ruc-lib/screen-recorder 3.1.0 → 3.2.0

package/esm2020/lib/services/screen-recorder.service.mjs

@@ -0,0 +1,333 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Subject, timer } from 'rxjs';
+import { takeWhile, tap } from 'rxjs/operators';
+import { RecordingState } from '../models/screen-recorder.models';
+import { ScreenRecorderConstants } from '../screen-recorder/screen-recorder-constant';
+import * as i0 from "@angular/core";
+import * as i1 from "../screen-recorder/screen-recorder-constant";
+export class ScreenRecorderService {
+    constructor(screenRecordingConstant) {
+        this.screenRecordingConstant = screenRecordingConstant;
+        this.stream = null;
+        this.mediaRecorder = null;
+        this.recordedBlobs = [];
+        this.currentRecordedTime = 0;
+        this.recordingStateSubject = new BehaviorSubject(RecordingState.Idle);
+        this.recordingState$ = this.recordingStateSubject.asObservable();
+        this.recordedTimeSubject = new BehaviorSubject(0);
+        this.recordedTime$ = this.recordedTimeSubject.asObservable();
+        this.recordedUrlSubject = new BehaviorSubject(null);
+        this.recordedUrl$ = this.recordedUrlSubject.asObservable();
+        this.recordingTimestampSubject = new BehaviorSubject('');
+        this.recordingTimestamp$ = this.recordingTimestampSubject.asObservable();
+        this.errorSubject = new Subject();
+        this.error$ = this.errorSubject.asObservable();
+    }
+    /**
+     * Starts the screen recording with optional audio
+     *
+     * @param options - Configuration options for recording
+     * @param options.audio - Whether to include audio in the recording
+     *
+     * @throws Error if recording is already in progress or if media access is denied
+     * @returns Promise<void>
+     */
+    async startRecording(options) {
+        if (this.recordingStateSubject.value === RecordingState.Recording || this.recordingStateSubject.value === RecordingState.Paused) {
+            this.handleError(this.screenRecordingConstant.RECORDING_IN_PROGRESS_ERROR);
+            return;
+        }
+        this.cleanupPreviousRecording();
+        try {
+            // The browser's native picker handles "specific area" selection (window, tab, screen).
+            const displayStream = await navigator.mediaDevices.getDisplayMedia({
+                video: true
+            });
+            // If audio is enabled, get the audio stream
+            let audioStream = null;
+            if (options.audio) {
+                audioStream = await navigator.mediaDevices.getUserMedia({
+                    audio: {
+                        echoCancellation: true,
+                        noiseSuppression: true,
+                        sampleRate: 44100
+                    }
+                });
+            }
+            // Combine the streams if audio is enabled
+            if (audioStream) {
+                this.stream = new MediaStream([...displayStream.getTracks(), ...audioStream.getTracks()]);
+            }
+            else {
+                this.stream = displayStream;
+            }
+            // Listen for when the user stops sharing via browser UI
+            this.stream.getVideoTracks()[0].onended = () => {
+                if (this.recordingStateSubject.value === RecordingState.Recording || this.recordingStateSubject.value === RecordingState.Paused) {
+                    this.stopRecordingInternal();
+                }
+            };
+            // Handle errors
+            if (!this.stream) {
+                this.handleError(this.screenRecordingConstant.FAILED_TO_GET_DISPLAY_MEDIA_STREAM_ERROR);
+                return;
+            }
+            // Set recording timestamp
+            const now = new Date();
+            const timestamp = now.toLocaleString('en-IN', {
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                hour12: true
+            });
+            this.recordingTimestampSubject.next(timestamp);
+            this.recordedBlobs = [];
+            const mimeType = this.getSupportedMimeType();
+            if (!mimeType) {
+                this.handleError(this.screenRecordingConstant.NO_SUPPORT_MIME);
+                this.stream?.getTracks().forEach(track => track.stop());
+                this.stream = null;
+                return;
+            }
+            // Create a canvas for timestamp overlay
+            const canvas = document.createElement('canvas');
+            const videoTrack = this.stream?.getVideoTracks()[0];
+            if (videoTrack) {
+                const video = document.createElement('video');
+                video.srcObject = this.stream;
+                // Wait for video to load metadata
+                video.onloadedmetadata = () => {
+                    canvas.width = video.videoWidth;
+                    canvas.height = video.videoHeight;
+                    const ctx = canvas.getContext('2d');
+                    if (ctx) {
+                        // Draw video frame
+                        ctx.drawImage(video, 0, 0);
+                        // Draw timestamp
+                        ctx.font = '16px Arial';
+                        ctx.fillStyle = 'white';
+                        ctx.textAlign = 'right';
+                        ctx.textBaseline = 'top';
+                        ctx.fillText(`Recorded on: ${this.recordingTimestampSubject.value}`, canvas.width - 10, 10);
+                    }
+                };
+            }
+            // Create a new stream with the canvas
+            const canvasStream = canvas.captureStream();
+            const combinedStream = new MediaStream([...this.stream?.getTracks() ?? [], canvasStream.getVideoTracks()[0]]);
+            this.mediaRecorder = new MediaRecorder(combinedStream, { mimeType });
+            this.mediaRecorder.ondataavailable = (event) => {
+                if (event.data && event.data.size > 0) {
+                    this.recordedBlobs.push(event.data);
+                }
+            };
+            this.mediaRecorder.onstop = () => {
+                const superBuffer = new Blob(this.recordedBlobs, { type: mimeType });
+                const url = window.URL.createObjectURL(superBuffer);
+                this.recordedUrlSubject.next(url);
+                this.recordingStateSubject.next(RecordingState.Stopped);
+                this.stopTimer();
+            };
+            this.mediaRecorder.onerror = (event) => {
+                const errorEvent = event; // More specific type if available
+                let message = this.screenRecordingConstant.MEDIA_ERROR;
+                if (errorEvent.error && errorEvent.error.name) {
+                    message += `: ${errorEvent.error.name}`;
+                    if (errorEvent.error.message)
+                        message += ` - ${errorEvent.error.message}`;
+                }
+                this.handleError(message);
+                this.recordingStateSubject.next(RecordingState.Idle);
+                this.stopTimer();
+            };
+            this.mediaRecorder.start(); // Start recording
+            this.recordingStateSubject.next(RecordingState.Recording);
+            this.startTimer();
+        }
+        catch (err) {
+            this.handleError(`Error starting screen recording: ${err.name} - ${err.message}`);
+            this.recordingStateSubject.next(RecordingState.Idle);
+        }
+    }
+    /**
+   * Gets the first supported MIME type for MediaRecorder
+   *
+   * @returns string|null - The supported MIME type or null if none found
+   */
+    getSupportedMimeType() {
+        const mimeTypes = [
+            'video/webm;codecs=vp9,opus',
+            'video/webm;codecs=vp8,opus',
+            'video/webm;codecs=h264,opus',
+            'video/mp4;codecs=h264,aac',
+            'video/webm',
+        ];
+        for (const mimeType of mimeTypes) {
+            if (MediaRecorder.isTypeSupported(mimeType)) {
+                return mimeType;
+            }
+        }
+        return null;
+    }
+    /**
+     * Internal method to stop the recording process
+     *
+     * @private
+     * @returns void
+     */
+    stopRecordingInternal() {
+        if (this.mediaRecorder && (this.recordingStateSubject.value === RecordingState.Recording || this.recordingStateSubject.value === RecordingState.Paused)) {
+            this.mediaRecorder.stop();
+        }
+        this.stream?.getTracks().forEach(track => track.stop());
+        this.stream = null;
+        // State will be updated by onstop handler
+    }
+    /**
+     *
+     * @returns Promise<void>
+     * @throws Error if recording is not in progress
+     */
+    stopRecording() {
+        this.stopRecordingInternal();
+    }
+    /**
+     * Pauses the current recording
+     *
+     * @returns Promise<void>
+     * @throws Error if recording is not in progress
+     */
+    pauseRecording() {
+        if (this.mediaRecorder && this.recordingStateSubject.value === RecordingState.Recording) {
+            this.mediaRecorder.pause();
+            this.recordingStateSubject.next(RecordingState.Paused);
+            this.stopTimer(); // Pauses the timer display
+        }
+    }
+    /**
+     * Resumes a paused recording
+     *
+     * @returns Promise<void>
+     * @throws Error if recording is not paused
+     */
+    resumeRecording() {
+        if (this.mediaRecorder && this.recordingStateSubject.value === RecordingState.Paused) {
+            this.mediaRecorder.resume();
+            this.recordingStateSubject.next(RecordingState.Recording);
+            this.startTimer(this.currentRecordedTime); // Resumes timer display
+        }
+    }
+    /**
+     *
+     * @param fileName
+     */
+    downloadRecording(fileName = 'recording.webm') {
+        const url = this.recordedUrlSubject.value;
+        const timestamp = this.recordingTimestampSubject.value;
+        if (url && timestamp) {
+            // Format the timestamp for filename (remove spaces and special characters)
+            const formattedTimestamp = timestamp.replace(/[^a-zA-Z0-9]/g, '_');
+            // Create filename with timestamp
+            const fileExtension = fileName.split('.').pop() || 'webm';
+            const newFileName = `screen_recording_${formattedTimestamp}.${fileExtension}`;
+            const a = document.createElement('a');
+            a.style.display = 'none';
+            a.href = url;
+            a.download = newFileName;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            // No need to revoke URL here if user might want to play it again.
+            // Revoke on cleanup or new recording.
+        }
+        else {
+            this.handleError(this.screenRecordingConstant.NO_RECORDING_DOWNLOAD);
+        }
+    }
+    /**
+   * Starts the recording timer
+   *
+   * @param startTime - Optional start time for the timer
+   * @private
+   * @returns void
+   */
+    startTimer(startTime = 0) {
+        this.stopTimer(); // Ensure no multiple timers
+        this.currentRecordedTime = startTime;
+        this.recordedTimeSubject.next(this.currentRecordedTime);
+        this.timerSubscription = timer(0, 1000)
+            .pipe(tap(() => {
+            if (this.recordingStateSubject.value === RecordingState.Recording) {
+                this.currentRecordedTime++;
+                this.recordedTimeSubject.next(this.currentRecordedTime);
+            }
+        }), takeWhile(() => this.recordingStateSubject.value === RecordingState.Recording))
+            .subscribe();
+    }
+    /**
+     * Stops the recording timer
+     *
+     * @private
+     * @returns void
+     */
+    stopTimer() {
+        if (this.timerSubscription) {
+            this.timerSubscription.unsubscribe();
+            this.timerSubscription = null;
+        }
+    }
+    /**
+     * Cleans up resources from previous recording
+     *
+     * @private
+     * @returns void
+     */
+    cleanupPreviousRecording() {
+        if (this.recordedUrlSubject.value) {
+            window.URL.revokeObjectURL(this.recordedUrlSubject.value);
+            this.recordedUrlSubject.next(null);
+        }
+        this.recordedBlobs = [];
+        this.currentRecordedTime = 0;
+        this.recordedTimeSubject.next(0);
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = null;
+        }
+        if (this.mediaRecorder && this.mediaRecorder.state !== this.screenRecordingConstant.INACTIVE) {
+            this.mediaRecorder.stop();
+        }
+        this.mediaRecorder = null;
+    }
+    /**
+   * Resets the recording state to idle
+   *
+   * @returns void
+   */
+    resetToIdle() {
+        this.cleanupPreviousRecording();
+        this.recordingStateSubject.next(RecordingState.Idle);
+        this.errorSubject.next(''); // Clear any previous errors
+    }
+    /**
+   * Handles and broadcasts recording errors
+   *
+   * @private
+   * @param error - The error message to handle
+   * @returns void
+   */
+    handleError(error) {
+        this.errorSubject.next(error);
+    }
+}
+ScreenRecorderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ScreenRecorderService, deps: [{ token: i1.ScreenRecorderConstants }], target: i0.ɵɵFactoryTarget.Injectable });
+ScreenRecorderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ScreenRecorderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ScreenRecorderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root', // Or provide in your module if preferred
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ScreenRecorderConstants }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"screen-recorder.service.js","sourceRoot":"","sources":["../../../../src/lib/services/screen-recorder.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject, Observable, Subject, timer } from 'rxjs';\r\nimport { takeWhile, tap } from 'rxjs/operators';\r\nimport { RecordingState } from '../models/screen-recorder.models';\r\nimport { ScreenRecorderConstants } from '../screen-recorder/screen-recorder-constant';\r\n@Injectable({\r\n  providedIn: 'root', // Or provide in your module if preferred\r\n})\r\nexport class ScreenRecorderService {\r\n  private stream: MediaStream | null = null;\r\n  private mediaRecorder: MediaRecorder | null = null;\r\n  private recordedBlobs: Blob[] = [];\r\n  private timerSubscription: any;\r\n  private currentRecordedTime: number = 0;\r\n\r\n  private readonly recordingStateSubject = new BehaviorSubject<RecordingState>(RecordingState.Idle);\r\n  readonly recordingState$: Observable<RecordingState> = this.recordingStateSubject.asObservable();\r\n\r\n  private readonly recordedTimeSubject = new BehaviorSubject<number>(0);\r\n  readonly recordedTime$: Observable<number> = this.recordedTimeSubject.asObservable();\r\n\r\n  private readonly recordedUrlSubject = new BehaviorSubject<string | null>(null);\r\n  readonly recordedUrl$: Observable<string | null> = this.recordedUrlSubject.asObservable();\r\n\r\n  private readonly recordingTimestampSubject = new BehaviorSubject<string>('');\r\n  readonly recordingTimestamp$: Observable<string> = this.recordingTimestampSubject.asObservable();\r\n\r\n  private readonly errorSubject = new Subject<string>();\r\n  readonly error$: Observable<string> = this.errorSubject.asObservable();\r\n\r\n  constructor(public screenRecordingConstant: ScreenRecorderConstants) { }\r\n\r\n  /**\r\n   * Starts the screen recording with optional audio\r\n   * \r\n   * @param options - Configuration options for recording\r\n   * @param options.audio - Whether to include audio in the recording\r\n   * \r\n   * @throws Error if recording is already in progress or if media access is denied\r\n   * @returns Promise<void>\r\n   */\r\n  async startRecording(options: { audio: boolean }): Promise<void> {\r\n\r\n    if (this.recordingStateSubject.value === RecordingState.Recording || this.recordingStateSubject.value === RecordingState.Paused) {\r\n      this.handleError(this.screenRecordingConstant.RECORDING_IN_PROGRESS_ERROR);\r\n      return;\r\n    }\r\n\r\n    this.cleanupPreviousRecording();\r\n\r\n    try {\r\n      // The browser's native picker handles \"specific area\" selection (window, tab, screen).\r\n      const displayStream = await navigator.mediaDevices.getDisplayMedia({\r\n        video: true\r\n      });\r\n\r\n      // If audio is enabled, get the audio stream\r\n      let audioStream: MediaStream | null = null;\r\n      if (options.audio) {\r\n        audioStream = await navigator.mediaDevices.getUserMedia({\r\n          audio: {\r\n            echoCancellation: true,\r\n            noiseSuppression: true,\r\n            sampleRate: 44100\r\n          }\r\n        });\r\n      }\r\n\r\n      // Combine the streams if audio is enabled\r\n      if (audioStream) {\r\n        this.stream = new MediaStream([...displayStream.getTracks(), ...audioStream.getTracks()]);\r\n      } else {\r\n        this.stream = displayStream;\r\n      }\r\n\r\n      // Listen for when the user stops sharing via browser UI\r\n      this.stream.getVideoTracks()[0].onended = () => {\r\n        if (this.recordingStateSubject.value === RecordingState.Recording || this.recordingStateSubject.value === RecordingState.Paused) {\r\n          this.stopRecordingInternal();\r\n        }\r\n      };\r\n\r\n      // Handle errors\r\n      if (!this.stream) {\r\n        this.handleError(this.screenRecordingConstant.FAILED_TO_GET_DISPLAY_MEDIA_STREAM_ERROR);\r\n        return;\r\n      }\r\n\r\n      // Set recording timestamp\r\n      const now = new Date();\r\n      const timestamp = now.toLocaleString('en-IN', {\r\n        year: 'numeric',\r\n        month: '2-digit',\r\n        day: '2-digit',\r\n        hour: '2-digit',\r\n        minute: '2-digit',\r\n        hour12: true\r\n      });\r\n      this.recordingTimestampSubject.next(timestamp);\r\n\r\n\r\n      this.recordedBlobs = [];\r\n      const mimeType = this.getSupportedMimeType();\r\n      if (!mimeType) {\r\n        this.handleError(this.screenRecordingConstant.NO_SUPPORT_MIME);\r\n        this.stream?.getTracks().forEach(track => track.stop());\r\n        this.stream = null;\r\n        return;\r\n      }\r\n\r\n      // Create a canvas for timestamp overlay\r\n      const canvas = document.createElement('canvas');\r\n      const videoTrack = this.stream?.getVideoTracks()[0];\r\n      if (videoTrack) {\r\n        const video = document.createElement('video');\r\n        video.srcObject = this.stream;\r\n\r\n        // Wait for video to load metadata\r\n        video.onloadedmetadata = () => {\r\n          canvas.width = video.videoWidth;\r\n          canvas.height = video.videoHeight;\r\n          const ctx = canvas.getContext('2d');\r\n          if (ctx) {\r\n            // Draw video frame\r\n            ctx.drawImage(video, 0, 0);\r\n\r\n            // Draw timestamp\r\n            ctx.font = '16px Arial';\r\n            ctx.fillStyle = 'white';\r\n            ctx.textAlign = 'right';\r\n            ctx.textBaseline = 'top';\r\n            ctx.fillText(`Recorded on: ${this.recordingTimestampSubject.value}`, canvas.width - 10, 10);\r\n          }\r\n        };\r\n      }\r\n\r\n      // Create a new stream with the canvas\r\n      const canvasStream = canvas.captureStream();\r\n      const combinedStream = new MediaStream([...this.stream?.getTracks() ?? [], canvasStream.getVideoTracks()[0]]);\r\n\r\n      this.mediaRecorder = new MediaRecorder(combinedStream, { mimeType });\r\n\r\n      this.mediaRecorder.ondataavailable = (event) => {\r\n        if (event.data && event.data.size > 0) {\r\n          this.recordedBlobs.push(event.data);\r\n        }\r\n      };\r\n\r\n      this.mediaRecorder.onstop = () => {\r\n        const superBuffer = new Blob(this.recordedBlobs, { type: mimeType });\r\n        const url = window.URL.createObjectURL(superBuffer);\r\n        this.recordedUrlSubject.next(url);\r\n        this.recordingStateSubject.next(RecordingState.Stopped);\r\n        this.stopTimer();\r\n\r\n      };\r\n\r\n      this.mediaRecorder.onerror = (event: Event) => {\r\n        const errorEvent = event as ErrorEvent; // More specific type if available\r\n        let message = this.screenRecordingConstant.MEDIA_ERROR;\r\n        if (errorEvent.error && errorEvent.error.name) {\r\n          message += `: ${errorEvent.error.name}`;\r\n          if (errorEvent.error.message) message += ` - ${errorEvent.error.message}`;\r\n        }\r\n        this.handleError(message);\r\n        this.recordingStateSubject.next(RecordingState.Idle);\r\n        this.stopTimer();\r\n      };\r\n\r\n      this.mediaRecorder.start(); // Start recording\r\n      this.recordingStateSubject.next(RecordingState.Recording);\r\n      this.startTimer();\r\n    } catch (err: any) {\r\n      this.handleError(`Error starting screen recording: ${err.name} - ${err.message}`);\r\n      this.recordingStateSubject.next(RecordingState.Idle);\r\n    }\r\n  }\r\n\r\n  /**\r\n * Gets the first supported MIME type for MediaRecorder\r\n * \r\n * @returns string|null - The supported MIME type or null if none found\r\n */\r\n  private getSupportedMimeType(): string | null {\r\n    const mimeTypes = [\r\n      'video/webm;codecs=vp9,opus',\r\n      'video/webm;codecs=vp8,opus',\r\n      'video/webm;codecs=h264,opus',\r\n      'video/mp4;codecs=h264,aac', // MP4 might have broader compatibility but less browser support for recording\r\n      'video/webm',\r\n    ];\r\n    for (const mimeType of mimeTypes) {\r\n      if (MediaRecorder.isTypeSupported(mimeType)) {\r\n        return mimeType;\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Internal method to stop the recording process\r\n   * \r\n   * @private\r\n   * @returns void\r\n   */\r\n  private stopRecordingInternal(): void {\r\n    if (this.mediaRecorder && (this.recordingStateSubject.value === RecordingState.Recording || this.recordingStateSubject.value === RecordingState.Paused)) {\r\n      this.mediaRecorder.stop();\r\n    }\r\n    this.stream?.getTracks().forEach(track => track.stop());\r\n    this.stream = null;\r\n    // State will be updated by onstop handler\r\n  }\r\n\r\n  /**\r\n   * \r\n   * @returns Promise<void>\r\n   * @throws Error if recording is not in progress\r\n   */\r\n  stopRecording(): void {\r\n    this.stopRecordingInternal();\r\n  }\r\n\r\n  /**\r\n   * Pauses the current recording\r\n   * \r\n   * @returns Promise<void>\r\n   * @throws Error if recording is not in progress\r\n   */\r\n  pauseRecording(): void {\r\n    if (this.mediaRecorder && this.recordingStateSubject.value === RecordingState.Recording) {\r\n      this.mediaRecorder.pause();\r\n      this.recordingStateSubject.next(RecordingState.Paused);\r\n      this.stopTimer(); // Pauses the timer display\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Resumes a paused recording\r\n   * \r\n   * @returns Promise<void>\r\n   * @throws Error if recording is not paused\r\n   */\r\n  resumeRecording(): void {\r\n    if (this.mediaRecorder && this.recordingStateSubject.value === RecordingState.Paused) {\r\n      this.mediaRecorder.resume();\r\n      this.recordingStateSubject.next(RecordingState.Recording);\r\n      this.startTimer(this.currentRecordedTime); // Resumes timer display\r\n    }\r\n  }\r\n\r\n  /**\r\n   * \r\n   * @param fileName \r\n   */\r\n  downloadRecording(fileName: string = 'recording.webm'): void {\r\n    const url = this.recordedUrlSubject.value;\r\n    const timestamp = this.recordingTimestampSubject.value;\r\n\r\n    if (url && timestamp) {\r\n      // Format the timestamp for filename (remove spaces and special characters)\r\n      const formattedTimestamp = timestamp.replace(/[^a-zA-Z0-9]/g, '_');\r\n      // Create filename with timestamp\r\n      const fileExtension = fileName.split('.').pop() || 'webm';\r\n      const newFileName = `screen_recording_${formattedTimestamp}.${fileExtension}`;\r\n\r\n      const a = document.createElement('a');\r\n      a.style.display = 'none';\r\n      a.href = url;\r\n      a.download = newFileName;\r\n      document.body.appendChild(a);\r\n      a.click();\r\n      document.body.removeChild(a);\r\n      // No need to revoke URL here if user might want to play it again.\r\n      // Revoke on cleanup or new recording.\r\n    } else {\r\n      this.handleError(this.screenRecordingConstant.NO_RECORDING_DOWNLOAD);\r\n    }\r\n  }\r\n\r\n  /**\r\n * Starts the recording timer\r\n * \r\n * @param startTime - Optional start time for the timer\r\n * @private\r\n * @returns void\r\n */\r\n  private startTimer(startTime: number = 0): void {\r\n    this.stopTimer(); // Ensure no multiple timers\r\n    this.currentRecordedTime = startTime;\r\n    this.recordedTimeSubject.next(this.currentRecordedTime);\r\n\r\n    this.timerSubscription = timer(0, 1000)\r\n      .pipe(\r\n        tap(() => {\r\n          if (this.recordingStateSubject.value === RecordingState.Recording) {\r\n            this.currentRecordedTime++;\r\n            this.recordedTimeSubject.next(this.currentRecordedTime);\r\n          }\r\n        }),\r\n        takeWhile(() => this.recordingStateSubject.value === RecordingState.Recording)\r\n      )\r\n      .subscribe();\r\n  }\r\n\r\n  /**\r\n   * Stops the recording timer\r\n   * \r\n   * @private\r\n   * @returns void\r\n   */\r\n  private stopTimer(): void {\r\n    if (this.timerSubscription) {\r\n      this.timerSubscription.unsubscribe();\r\n      this.timerSubscription = null;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Cleans up resources from previous recording\r\n   * \r\n   * @private\r\n   * @returns void\r\n   */\r\n  private cleanupPreviousRecording(): void {\r\n    if (this.recordedUrlSubject.value) {\r\n      window.URL.revokeObjectURL(this.recordedUrlSubject.value);\r\n      this.recordedUrlSubject.next(null);\r\n    }\r\n    this.recordedBlobs = [];\r\n    this.currentRecordedTime = 0;\r\n    this.recordedTimeSubject.next(0);\r\n    if (this.stream) {\r\n      this.stream.getTracks().forEach(track => track.stop());\r\n      this.stream = null;\r\n    }\r\n    if (this.mediaRecorder && this.mediaRecorder.state !== this.screenRecordingConstant.INACTIVE) {\r\n      this.mediaRecorder.stop();\r\n    }\r\n    this.mediaRecorder = null;\r\n  }\r\n\r\n\r\n  /**\r\n * Resets the recording state to idle\r\n * \r\n * @returns void\r\n */\r\n  resetToIdle(): void {\r\n    this.cleanupPreviousRecording();\r\n    this.recordingStateSubject.next(RecordingState.Idle);\r\n    this.errorSubject.next(''); // Clear any previous errors\r\n  }\r\n\r\n\r\n  /**\r\n * Handles and broadcasts recording errors\r\n * \r\n * @private\r\n * @param error - The error message to handle\r\n * @returns void\r\n */\r\n  private handleError(error: string): void {\r\n    this.errorSubject.next(error);\r\n  }\r\n}\r\n"]}

package/esm2020/ruc-lib-screen-recorder.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVjLWxpYi1zY3JlZW4tcmVjb3JkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVjLWxpYi1zY3JlZW4tcmVjb3JkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=