@medc-com-br/ngx-jaimes-scribe 0.1.2 → 0.1.4

package/src/lib/services/audio-capture.service.ts

@@ -1,190 +0,0 @@
-import { Injectable, InjectionToken, inject, NgZone } from '@angular/core';
-import { Subject, Observable, BehaviorSubject } from 'rxjs';
-import { VadService } from './vad.service';
-
-export interface AudioCaptureConfig {
-  workletUrl: string;
-  levelUpdateInterval: number;
-}
-
-export const AUDIO_CAPTURE_CONFIG = new InjectionToken<AudioCaptureConfig>('AUDIO_CAPTURE_CONFIG');
-
-const DEFAULT_CONFIG: AudioCaptureConfig = {
-  workletUrl: '/assets/pcm-processor.js',
-  levelUpdateInterval: 50,
-};
-
-export interface AudioChunk {
-  data: ArrayBuffer;
-  isSilence: boolean;
-}
-
-@Injectable({ providedIn: 'root' })
-export class AudioCaptureService {
-  private config: AudioCaptureConfig;
-  private ngZone: NgZone;
-  private vadService: VadService;
-  private audioContext: AudioContext | null = null;
-  private workletNode: AudioWorkletNode | null = null;
-  private analyserNode: AnalyserNode | null = null;
-  private source: MediaStreamAudioSourceNode | null = null;
-  private stream: MediaStream | null = null;
-  private workletRegistered = false;
-  private levelInterval: ReturnType<typeof setInterval> | null = null;
-  private paused = false;
-
-  private audioChunkSubject = new Subject<AudioChunk>();
-  private audioLevelSubject = new BehaviorSubject<number>(0);
-  private errorSubject = new Subject<Error>();
-
-  audioChunk$: Observable<AudioChunk> = this.audioChunkSubject.asObservable();
-  audioLevel$: Observable<number> = this.audioLevelSubject.asObservable();
-  error$: Observable<Error> = this.errorSubject.asObservable();
-
-  constructor() {
-    const injectedConfig = inject(AUDIO_CAPTURE_CONFIG, { optional: true });
-    this.config = injectedConfig ?? DEFAULT_CONFIG;
-    this.ngZone = inject(NgZone);
-    this.vadService = inject(VadService);
-  }
-
-  async startCapture(): Promise<void> {
-    try {
-      this.stream = await navigator.mediaDevices.getUserMedia({
-        audio: {
-          channelCount: 1,
-          echoCancellation: true,
-          noiseSuppression: true,
-        },
-      });
-
-      this.audioContext = new AudioContext();
-
-      if (!this.workletRegistered) {
-        await this.audioContext.audioWorklet.addModule(this.config.workletUrl);
-        this.workletRegistered = true;
-      }
-
-      this.workletNode = new AudioWorkletNode(this.audioContext, 'pcm-processor', {
-        processorOptions: {
-          inputSampleRate: this.audioContext.sampleRate,
-        },
-      });
-
-      this.workletNode.port.onmessage = (event: MessageEvent<ArrayBuffer>) => {
-        if (!this.paused) {
-          const level = this.getAudioLevel();
-          const { isSilence } = this.vadService.analyzeLevel(level);
-          this.audioChunkSubject.next({ data: event.data, isSilence });
-        }
-      };
-
-      this.analyserNode = this.audioContext.createAnalyser();
-      this.analyserNode.fftSize = 256;
-      this.analyserNode.smoothingTimeConstant = 0.8;
-
-      this.source = this.audioContext.createMediaStreamSource(this.stream);
-      this.source.connect(this.analyserNode);
-      this.source.connect(this.workletNode);
-
-      this.startLevelMonitoring();
-    } catch (error) {
-      const err = error instanceof Error ? error : new Error('Failed to start audio capture');
-      this.errorSubject.next(err);
-      throw err;
-    }
-  }
-
-  async stopCapture(): Promise<void> {
-    this.stopLevelMonitoring();
-    this.paused = false;
-    this.vadService.reset();
-
-    if (this.workletNode) {
-      this.workletNode.port.close();
-      this.workletNode.disconnect();
-      this.workletNode = null;
-    }
-
-    if (this.analyserNode) {
-      this.analyserNode.disconnect();
-      this.analyserNode = null;
-    }
-
-    if (this.source) {
-      this.source.disconnect();
-      this.source = null;
-    }
-
-    if (this.audioContext) {
-      await this.audioContext.close();
-      this.audioContext = null;
-      this.workletRegistered = false;
-    }
-
-    if (this.stream) {
-      this.stream.getTracks().forEach((track) => track.stop());
-      this.stream = null;
-    }
-
-    this.audioLevelSubject.next(0);
-  }
-
-  pauseCapture(): void {
-    if (this.isCapturing() && !this.paused) {
-      this.paused = true;
-    }
-  }
-
-  resumeCapture(): void {
-    if (this.isCapturing() && this.paused) {
-      this.paused = false;
-    }
-  }
-
-  isCapturing(): boolean {
-    return this.workletNode !== null && this.stream !== null;
-  }
-
-  isPaused(): boolean {
-    return this.paused;
-  }
-
-  getSampleRate(): number | null {
-    return this.audioContext?.sampleRate ?? null;
-  }
-
-  private startLevelMonitoring(): void {
-    this.stopLevelMonitoring();
-
-    this.ngZone.runOutsideAngular(() => {
-      this.levelInterval = setInterval(() => {
-        const level = this.getAudioLevel();
-        this.ngZone.run(() => {
-          this.audioLevelSubject.next(level);
-        });
-      }, this.config.levelUpdateInterval);
-    });
-  }
-
-  private stopLevelMonitoring(): void {
-    if (this.levelInterval) {
-      clearInterval(this.levelInterval);
-      this.levelInterval = null;
-    }
-  }
-
-  private getAudioLevel(): number {
-    if (!this.analyserNode) {
-      return 0;
-    }
-
-    const dataArray = new Uint8Array(this.analyserNode.frequencyBinCount);
-    this.analyserNode.getByteFrequencyData(dataArray);
-
-    const sum = dataArray.reduce((acc, val) => acc + val, 0);
-    const average = sum / dataArray.length;
-
-    return Math.round((average / 255) * 100);
-  }
-}

package/src/lib/services/scribe-socket.service.ts

@@ -1,264 +0,0 @@
-import { Injectable, InjectionToken, inject, NgZone } from '@angular/core';
-import { BehaviorSubject, Subject, Observable } from 'rxjs';
-import type { TranscriptionEvent } from '@medc-com-br/jaimes-shared';
-
-export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
-
-export interface ScribeSocketConfig {
-  reconnectAttempts: number;
-  reconnectBaseDelay: number;
-  chunkBufferInterval: number;
-}
-
-export const SCRIBE_SOCKET_CONFIG = new InjectionToken<ScribeSocketConfig>('SCRIBE_SOCKET_CONFIG');
-
-const DEFAULT_CONFIG: ScribeSocketConfig = {
-  reconnectAttempts: 5,
-  reconnectBaseDelay: 1000,
-  chunkBufferInterval: 250,
-};
-
-@Injectable({ providedIn: 'root' })
-export class ScribeSocketService {
-  private config: ScribeSocketConfig;
-  private ngZone: NgZone;
-  private ws: WebSocket | null = null;
-  private wsUrl: string | null = null;
-  private token: string | null = null;
-  private premium = false;
-  private reconnectAttempt = 0;
-  private reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
-  private intentionalClose = false;
-
-  private chunkBuffer: string[] = [];
-  private sendInterval: ReturnType<typeof setInterval> | null = null;
-  private keepaliveInterval: ReturnType<typeof setInterval> | null = null;
-  private currentlyInSilence = false;
-
-  private connectionStateSubject = new BehaviorSubject<ConnectionState>('disconnected');
-  private transcriptionSubject = new Subject<TranscriptionEvent>();
-  private errorSubject = new Subject<Error>();
-  private sessionIdSubject = new BehaviorSubject<string | null>(null);
-
-  connectionState$: Observable<ConnectionState> = this.connectionStateSubject.asObservable();
-  transcription$: Observable<TranscriptionEvent> = this.transcriptionSubject.asObservable();
-  error$: Observable<Error> = this.errorSubject.asObservable();
-  sessionId$: Observable<string | null> = this.sessionIdSubject.asObservable();
-
-  constructor() {
-    const injectedConfig = inject(SCRIBE_SOCKET_CONFIG, { optional: true });
-    this.config = injectedConfig ?? DEFAULT_CONFIG;
-    this.ngZone = inject(NgZone);
-  }
-
-  async connect(url: string, token: string, premium = false): Promise<void> {
-    if (this.connectionStateSubject.getValue() === 'connecting') {
-      throw new Error('Connection already in progress');
-    }
-
-    if (this.isConnected()) {
-      this.disconnect();
-    }
-
-    this.clearReconnectTimeout();
-    this.wsUrl = url;
-    this.token = token;
-    this.premium = premium;
-    this.intentionalClose = false;
-    this.reconnectAttempt = 0;
-
-    return this.createConnection();
-  }
-
-  disconnect(): void {
-    this.intentionalClose = true;
-    this.flushAndStopBuffering();
-    this.clearReconnectTimeout();
-
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.close(1000, 'Client disconnect');
-    }
-    this.ws = null;
-
-    this.connectionStateSubject.next('disconnected');
-    this.sessionIdSubject.next(null);
-  }
-
-  sendAudioChunk(chunk: ArrayBuffer, isSilence: boolean): void {
-    const message = JSON.stringify({
-      type: 'audio',
-      isSilence,
-      data: this.arrayBufferToBase64(chunk),
-    });
-    this.chunkBuffer.push(message);
-
-    if (isSilence && !this.currentlyInSilence) {
-      this.currentlyInSilence = true;
-      this.startKeepaliveInterval();
-    } else if (!isSilence && this.currentlyInSilence) {
-      this.currentlyInSilence = false;
-      this.stopKeepaliveInterval();
-    }
-  }
-
-  private startKeepaliveInterval(): void {
-    this.stopKeepaliveInterval();
-    this.keepaliveInterval = setInterval(() => {
-      if (this.isConnected()) {
-        this.ws!.send(JSON.stringify({ type: 'keepalive' }));
-      }
-    }, 3000);
-  }
-
-  private stopKeepaliveInterval(): void {
-    if (this.keepaliveInterval) {
-      clearInterval(this.keepaliveInterval);
-      this.keepaliveInterval = null;
-    }
-  }
-
-  private arrayBufferToBase64(buffer: ArrayBuffer): string {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-
-  isConnected(): boolean {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-
-  getSessionId(): string | null {
-    return this.sessionIdSubject.getValue();
-  }
-
-  private createConnection(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!this.wsUrl) {
-        reject(new Error('WebSocket URL is required'));
-        return;
-      }
-
-      this.connectionStateSubject.next('connecting');
-      const params = new URLSearchParams({ premium: String(this.premium) });
-      if (this.token) {
-        params.set('token', this.token);
-      }
-      const url = `${this.wsUrl}?${params.toString()}`;
-
-      this.ws = new WebSocket(url);
-      this.ws.binaryType = 'arraybuffer';
-
-      this.ws.onopen = () => {
-        this.ngZone.run(() => {
-          this.reconnectAttempt = 0;
-          this.connectionStateSubject.next('connected');
-          this.startBuffering();
-          resolve();
-        });
-      };
-
-      this.ws.onerror = () => {
-        this.ngZone.run(() => {
-          const error = new Error('WebSocket connection error');
-          this.errorSubject.next(error);
-          if (this.connectionStateSubject.getValue() === 'connecting') {
-            reject(error);
-          }
-        });
-      };
-
-      this.ws.onmessage = (event) => {
-        this.ngZone.run(() => {
-          try {
-            const data = JSON.parse(event.data);
-            if (data.type === 'connected' && data.sessionId) {
-              this.sessionIdSubject.next(data.sessionId);
-            }
-            this.transcriptionSubject.next(data as TranscriptionEvent);
-          } catch (e) {
-            const error = new Error(`Failed to parse WebSocket message: ${e instanceof Error ? e.message : String(e)}`);
-            console.error(error.message);
-            this.errorSubject.next(error);
-          }
-        });
-      };
-
-      this.ws.onclose = (event) => {
-        this.ngZone.run(() => {
-          this.stopBuffering();
-
-          if (!this.intentionalClose && event.code !== 1000) {
-            this.attemptReconnect();
-          } else {
-            this.connectionStateSubject.next('disconnected');
-            this.sessionIdSubject.next(null);
-          }
-        });
-      };
-    });
-  }
-
-  private attemptReconnect(): void {
-    if (this.reconnectAttempt >= this.config.reconnectAttempts) {
-      this.connectionStateSubject.next('disconnected');
-      this.errorSubject.next(new Error('Max reconnection attempts reached'));
-      return;
-    }
-
-    this.connectionStateSubject.next('reconnecting');
-    const delay = this.config.reconnectBaseDelay * Math.pow(2, this.reconnectAttempt);
-    this.reconnectAttempt++;
-
-    this.reconnectTimeout = setTimeout(() => {
-      this.createConnection().catch(() => {});
-    }, delay);
-  }
-
-  private clearReconnectTimeout(): void {
-    if (this.reconnectTimeout) {
-      clearTimeout(this.reconnectTimeout);
-      this.reconnectTimeout = null;
-    }
-  }
-
-  private startBuffering(): void {
-    this.stopBuffering();
-
-    this.sendInterval = setInterval(() => {
-      if (this.chunkBuffer.length > 0 && this.isConnected()) {
-        for (const msg of this.chunkBuffer) {
-          this.ws!.send(msg);
-        }
-        this.chunkBuffer = [];
-      }
-    }, this.config.chunkBufferInterval);
-  }
-
-  private flushAndStopBuffering(): void {
-    if (this.sendInterval) {
-      clearInterval(this.sendInterval);
-      this.sendInterval = null;
-    }
-
-    if (this.chunkBuffer.length > 0 && this.isConnected()) {
-      for (const msg of this.chunkBuffer) {
-        this.ws!.send(msg);
-      }
-    }
-    this.chunkBuffer = [];
-    this.stopKeepaliveInterval();
-    this.currentlyInSilence = false;
-  }
-
-  private stopBuffering(): void {
-    if (this.sendInterval) {
-      clearInterval(this.sendInterval);
-      this.sendInterval = null;
-    }
-    this.chunkBuffer = [];
-  }
-
-}

package/src/lib/services/vad.service.ts

@@ -1,65 +0,0 @@
-import { Injectable } from '@angular/core';
-import { BehaviorSubject } from 'rxjs';
-
-export type VadState = 'idle' | 'speech' | 'silence_pending' | 'silence';
-
-export interface VadConfig {
-  speechThreshold: number;
-  silenceThreshold: number;
-  silenceDebounceMs: number;
-}
-
-const DEFAULT_CONFIG: VadConfig = {
-  speechThreshold: 8,
-  silenceThreshold: 3,
-  silenceDebounceMs: 1500,
-};
-
-@Injectable({ providedIn: 'root' })
-export class VadService {
-  private state: VadState = 'idle';
-  private silenceStartTime: number | null = null;
-  private config = { ...DEFAULT_CONFIG };
-
-  readonly state$ = new BehaviorSubject<VadState>('idle');
-
-  analyzeLevel(level: number): { isSilence: boolean } {
-    const now = Date.now();
-
-    if (level >= this.config.speechThreshold) {
-      this.state = 'speech';
-      this.silenceStartTime = null;
-      this.state$.next('speech');
-      return { isSilence: false };
-    }
-
-    if (level < this.config.silenceThreshold) {
-      if (this.state === 'speech') {
-        this.silenceStartTime = now;
-        this.state = 'silence_pending';
-      } else if (this.state === 'silence_pending' && this.silenceStartTime) {
-        if (now - this.silenceStartTime >= this.config.silenceDebounceMs) {
-          this.state = 'silence';
-          this.state$.next('silence');
-        }
-      }
-    } else {
-      if (this.state === 'silence_pending') {
-        this.state = 'speech';
-        this.silenceStartTime = null;
-      }
-    }
-
-    return { isSilence: this.state === 'silence' };
-  }
-
-  reset(): void {
-    this.state = 'idle';
-    this.silenceStartTime = null;
-    this.state$.next('idle');
-  }
-
-  getState(): VadState {
-    return this.state;
-  }
-}

package/src/lib/worklets/audio-worklet.d.ts

@@ -1,14 +0,0 @@
-declare class AudioWorkletProcessor {
-  readonly port: MessagePort;
-  constructor(options?: AudioWorkletNodeOptions);
-  process(
-    inputs: Float32Array[][],
-    outputs: Float32Array[][],
-    parameters: Record<string, Float32Array>
-  ): boolean;
-}
-
-declare function registerProcessor(
-  name: string,
-  processorCtor: new (options?: AudioWorkletNodeOptions) => AudioWorkletProcessor
-): void;

package/src/lib/worklets/pcm-processor.worklet.ts

@@ -1,81 +0,0 @@
-/// <reference path="./audio-worklet.d.ts" />
-
-const TARGET_SAMPLE_RATE = 16000;
-const BUFFER_SIZE = 4096;
-
-class PcmProcessor extends AudioWorkletProcessor {
-  private inputSampleRate: number;
-  private resampleRatio: number;
-  private inputBuffer: Float32Array;
-  private inputBufferIndex: number;
-  private resampleBuffer: Float32Array;
-  private resampleBufferIndex: number;
-
-  constructor(options?: AudioWorkletNodeOptions) {
-    super();
-
-    this.inputSampleRate = (options?.processorOptions?.inputSampleRate as number) || 48000;
-    this.resampleRatio = this.inputSampleRate / TARGET_SAMPLE_RATE;
-
-    this.inputBuffer = new Float32Array(BUFFER_SIZE * 2);
-    this.inputBufferIndex = 0;
-
-    const outputBufferSize = Math.ceil(BUFFER_SIZE / this.resampleRatio);
-    this.resampleBuffer = new Float32Array(outputBufferSize);
-    this.resampleBufferIndex = 0;
-  }
-
-  process(inputs: Float32Array[][], _outputs: Float32Array[][], _parameters: Record<string, Float32Array>): boolean {
-    const input = inputs[0];
-    if (!input || !input[0]) {
-      return true;
-    }
-
-    const inputChannel = input[0];
-
-    for (let i = 0; i < inputChannel.length; i++) {
-      this.inputBuffer[this.inputBufferIndex++] = inputChannel[i];
-
-      if (this.inputBufferIndex >= BUFFER_SIZE) {
-        this.processBuffer();
-      }
-    }
-
-    return true;
-  }
-
-  private processBuffer(): void {
-    const outputLength = Math.floor(this.inputBufferIndex / this.resampleRatio);
-
-    for (let i = 0; i < outputLength; i++) {
-      const srcIndex = i * this.resampleRatio;
-      const srcIndexFloor = Math.floor(srcIndex);
-      const srcIndexCeil = Math.min(srcIndexFloor + 1, this.inputBufferIndex - 1);
-      const t = srcIndex - srcIndexFloor;
-
-      const sample = this.inputBuffer[srcIndexFloor] * (1 - t) + this.inputBuffer[srcIndexCeil] * t;
-      this.resampleBuffer[this.resampleBufferIndex++] = sample;
-    }
-
-    const pcmData = this.float32ToPcm16(this.resampleBuffer.subarray(0, this.resampleBufferIndex));
-    this.port.postMessage(pcmData, [pcmData]);
-
-    this.inputBufferIndex = 0;
-    this.resampleBufferIndex = 0;
-  }
-
-  private float32ToPcm16(float32Array: Float32Array): ArrayBuffer {
-    const buffer = new ArrayBuffer(float32Array.length * 2);
-    const view = new DataView(buffer);
-
-    for (let i = 0; i < float32Array.length; i++) {
-      const sample = Math.max(-1, Math.min(1, float32Array[i]));
-      const int16 = sample < 0 ? sample * 0x8000 : sample * 0x7fff;
-      view.setInt16(i * 2, int16, true);
-    }
-
-    return buffer;
-  }
-}
-
-registerProcessor('pcm-processor', PcmProcessor);

package/tsconfig.lib.json

@@ -1,24 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "target": "ES2022",
-    "module": "ES2022",
-    "moduleResolution": "bundler",
-    "declaration": true,
-    "declarationMap": true,
-    "inlineSources": true,
-    "experimentalDecorators": true,
-    "importHelpers": true,
-    "types": [],
-    "lib": ["ES2022", "dom"]
-  },
-  "angularCompilerOptions": {
-    "enableI18nLegacyMessageIdFormat": false,
-    "strictInjectionParameters": true,
-    "strictInputAccessModifiers": true,
-    "strictTemplates": true
-  },
-  "exclude": ["**/*.spec.ts"],
-  "include": ["src/**/*.ts"]
-}