@prabhjeet.me/wakeywakey 1.0.0

package/index.d.ts

@@ -0,0 +1,675 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy, EventEmitter } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as _prabhjeet_me_wakeywakey from '@prabhjeet.me/wakeywakey';
+import { InferenceSession } from 'onnxruntime-web';
+
+/**
+ * Audio utility
+ */
+declare class AudioUtil {
+    /**
+     * Create wav blob url from audio chunk
+     *
+     * @param chunks Audio chunk
+     * @param sampleRate Sample rate
+     * @returns
+     */
+    static createWavBlob(chunks: Float32Array[], sampleRate?: number): string | null;
+}
+
+interface OrbConfig {
+    /**
+     * Height and width (px)
+     */
+    size?: number;
+}
+
+interface AudioConfig {
+    /**
+     * Audio gain
+     */
+    gain: number;
+    /**
+     * Voice activity detection threshold
+     *
+     * Default: 0.5
+     */
+    vadThreshold?: number;
+    /**
+     * Silence duration
+     *
+     * Default: 1000ms
+     */
+    silenceDuration?: number;
+    /**
+     * Use RNN to suppress noise
+     */
+    noiseSuppression?: {
+        /**
+         * Enable noise suppression
+         */
+        enable?: boolean;
+        /**
+         * RNNoise worklet js
+         *
+         * Default: [basePath]/worklets/workletProcessor.js
+         */
+        worklet?: string;
+        /**
+         * RNNoise wasm file
+         *
+         * Default: [basePath]/wasm/rnnoise.wasm
+         */
+        rnnoise?: string;
+        /**
+         * RNNoise simd wasm file
+         *
+         * Default: [basePath]/wasm/rnnoise_simd.wasm
+         */
+        rnnoise_simd?: string;
+    };
+    /**
+     * Paths
+     */
+    sound?: {
+        /**
+         * Enable sound
+         *
+         * Default: true
+         */
+        enable?: boolean;
+        /**
+         * Path of sound to be played when wake word is detected
+         *
+         * Default: [basePath]/sounds/up.mp3
+         */
+        up?: string;
+        /**
+         * Path of sound to be played when system is done recording and silence is detected
+         *
+         * Default: [basePath]/sounds/down.mp3
+         */
+        down?: string;
+    };
+}
+
+interface OnnxConfig {
+    model: {
+        /**
+         * Mel Spectrogram model (.onnx)
+         *
+         * Default: [basePath]/models/melspectrogram.onnx
+         */
+        melspectrogram?: string;
+        /**
+         * Embedding model (.onnx)
+         *
+         * Default: [basePath]/models/embedding_model.onnx
+         */
+        embedding_model?: string;
+        /**
+         * Silero VAD (.onnx)
+         *
+         * Default: [basePath]/models/silero_vad_v4.onnx
+         */
+        silero_vad?: string;
+        /**
+         * Wake word model (.onnx)
+         */
+        wakeword: string;
+    };
+    /**
+     * Path that contains onnx wasm runtime files
+     *
+     * Default: [basePath]/wasm
+     */
+    runtimePath?: string;
+    /**
+     * Wake word inference threshold
+     *
+     * Default: 0.5
+     */
+    wakewordInferenceThreshold?: number;
+}
+type InferenceModels = keyof OnnxConfig['model'];
+
+/**
+ * Wakey wakey configuration
+ */
+interface Config {
+    /**
+     * Audio config
+     */
+    audio: AudioConfig;
+    /**
+     * Onnx config
+     */
+    onnx: OnnxConfig;
+    /**
+     * Orb config
+     */
+    orb?: OrbConfig;
+    /**
+     * In sliding window, there is a possibility of detecting wakeword mode than once.
+     * This allows a cool down time before processing subsequent detections
+     *
+     * Default: 1000 (1 seconds)
+     */
+    throttleTime?: number;
+    /**
+     * DEFAULT: [WAKEWORD] -> Start Recording -> Silence (Spoken chunk & transcript) -> Done -> [WAKEWORD] .....
+     * CHAT: [WAKEWORD] -> Start Recording -> Silence -> [Speaking] ->  Start Recording -> Silence .....
+     */
+    mode?: 'DEFAULT' | 'VOICE_CHAT';
+    /**
+     * Base asset path. This path will be used to access required resources
+     *
+     * Default: /wakeywakey
+     */
+    basePath?: string;
+}
+/**
+ * Wakey wakey config token
+ */
+declare const CONFIG: InjectionToken<Config>;
+
+/**
+ * Microphone processor data
+ */
+interface MicrophoneProcessorData {
+    /**
+     * Audio sample
+     */
+    sample: Float32Array;
+    /**
+     * RMS value  of sample
+     */
+    rms: number;
+    /**
+     * Decibel of sample
+     */
+    db: number;
+    /**
+     * Normalized decibel (0-1)
+     */
+    dbNormalized: number;
+}
+
+/**
+ * Speech event emitter
+ */
+interface SpeechEvent extends MicrophoneProcessorData {
+    /**
+     * VAD score of input
+     */
+    vadScore: number;
+    /**
+     * Has voice activity
+     */
+    get hasVoiceActivity(): boolean;
+}
+/**
+ * Wake work detected event
+ */
+interface WakeWordEvent extends SpeechEvent {
+    /**
+     * Inference score
+     */
+    inferenceScore: number;
+    /**
+     * Chunk of detected wakeword
+     */
+    chunk: Float32Array[];
+}
+/**
+ * Silence event
+ */
+interface SilenceEvent {
+    /**
+     * Chunk of detected wakeword
+     */
+    chunk: Float32Array;
+    /**
+     * Transcript of speech
+     */
+    transcript: string;
+    /**
+     * For DEFAULT mode: always false
+     * For VOICE_CHAT mode: true if constant chat is going on, false if stopped
+     */
+    interimResponse: boolean;
+}
+
+declare class WakeyWakeyComponent implements OnInit, OnDestroy {
+    /**
+     * Fires when library loaded
+     */
+    ready: EventEmitter<void>;
+    /**
+     * Fires when there is an error
+     */
+    exception: EventEmitter<Error>;
+    /**
+     * Fires when speech is detected
+     */
+    speech: EventEmitter<SpeechEvent>;
+    /**
+     * Fires when wake word is detected
+     */
+    wakeword: EventEmitter<WakeWordEvent>;
+    /**
+     * Fires when recording starts (after wake word detection)
+     */
+    recording: EventEmitter<void>;
+    /**
+     * Fires silence is detected
+     */
+    silence: EventEmitter<SilenceEvent>;
+    /**
+     * Dependencies
+     */
+    private readonly _config;
+    /**
+     * Dependencies
+     */
+    private readonly _platform;
+    private readonly _event;
+    private readonly _audio;
+    private readonly _model;
+    /**
+     * Subscriptions
+     */
+    private readonly _subs;
+    ngOnInit(): void;
+    /**
+     * Fire face wakeword event
+     */
+    fireWakeWord(): void;
+    ngOnDestroy(): void;
+    /**
+     * Execute
+     */
+    private _execute;
+    /**
+     * Listen events
+     */
+    private _listenEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WakeyWakeyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WakeyWakeyComponent, "wakeywakey", never, {}, { "ready": "ready"; "exception": "exception"; "speech": "speech"; "wakeword": "wakeword"; "recording": "recording"; "silence": "silence"; }, never, never, true, never>;
+}
+
+declare class AudioService implements OnDestroy {
+    /**
+     * Dependencies
+     */
+    private readonly __speaker;
+    private readonly _config;
+    private readonly _event;
+    private readonly _mic;
+    private readonly _vad;
+    private readonly _pipeline;
+    private readonly _speechRecognition;
+    private readonly _subs;
+    private _endCurrentRecording;
+    /**
+     * Recording state
+     */
+    private _isRecording;
+    /**
+     * Is process is initialized (detected wakeword)
+     */
+    private _isInitialized;
+    get isRecording(): boolean;
+    ngOnDestroy(): void;
+    /**
+     * Initialize audio
+     */
+    init(): Promise<void>;
+    /**
+     * Force start recording (without wakeword)
+     */
+    forceStartRecording(): void;
+    /**
+     * Force end recording
+     */
+    forceEndRecording(): void;
+    /**
+     * Toggle recording
+     */
+    toggleRecording(): void;
+    /**
+     * Identifies the wakeword and emits the event
+     */
+    private _listenForWakeword;
+    /**
+     * New logic: Captures the full command audio after a wakeword
+     */
+    private _captureCommandAfterWakeword;
+    /**
+     * Helper to flatten array of buffers into a single Float32Array
+     */
+    private _flatten;
+    /**
+     * Wakeword stream
+     * @returns
+     */
+    private _getWakeWordStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AudioService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AudioService>;
+}
+
+declare class MicrophoneService implements OnDestroy {
+    /**
+     * Dependencies
+     */
+    private readonly _event;
+    private readonly _config;
+    /**
+     * Audio data subject
+     */
+    private readonly _data;
+    /**
+     * List of available microphones
+     */
+    private _microphones;
+    /**
+     * Media steam
+     */
+    private _stream;
+    /**
+     * Audio context
+     */
+    private _audioContext?;
+    constructor();
+    /**
+     * List of available microphones
+     */
+    get microphones(): MediaDeviceInfo[];
+    /**
+     * Microphone data
+     */
+    get data(): Subject<MicrophoneProcessorData>;
+    /**
+     * Set input source
+     */
+    set source(deviceId: string);
+    ngOnDestroy(): void;
+    /**
+     * Initialize
+     *
+     * @param deviceId Input device id (from microphone list)
+     */
+    private _init;
+    /**
+     * Monitor audio
+     *
+     * @returns chunk subject
+     */
+    private _monitor;
+    /**
+     * Save microphones
+     */
+    private _microphoneList;
+    /**
+     * Prepare worklet node
+     */
+    private _workletNode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MicrophoneService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MicrophoneService>;
+}
+
+declare class SpeakerService implements OnDestroy {
+    /**
+     * Dependencies
+     */
+    private readonly _config;
+    private readonly _platform;
+    private readonly _event;
+    private readonly _subs;
+    private _upSound;
+    private _downSound;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * Play on sound
+     */
+    playUp(): void;
+    /**
+     * Play off sound
+     */
+    playDown(): void;
+    /**
+     * Load subscriptions
+     */
+    private _loadSubscriptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpeakerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpeakerService>;
+}
+
+declare class SpeechRecognitionService implements OnDestroy {
+    /**
+     * Dependencies
+     */
+    private readonly _event;
+    private readonly _platform;
+    private _recognitionClass;
+    /**
+     * Instance
+     */
+    private _recognition;
+    /**
+     * Transcript
+     */
+    private _transcript;
+    /**
+     * Get transcript
+     */
+    get transcript(): string;
+    ngOnDestroy(): void;
+    /**
+     * Clear transcript
+     */
+    reset(): void;
+    init(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpeechRecognitionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpeechRecognitionService>;
+}
+
+declare class VadService {
+    /**
+     * Dependencies
+     */
+    private readonly _event;
+    private readonly _model;
+    /**
+     * VAD Shape
+     */
+    private _shape;
+    /**
+     * VAD LSTM hidden & cell state
+     */
+    private _state;
+    /**
+     * Get session
+     */
+    private get _session();
+    /**
+     * Initialize
+     */
+    init(): void;
+    /**
+     * Get VAD score
+     *
+     * @param chunk
+     * @returns
+     */
+    score(sample: Float32Array): Promise<number>;
+    /**
+     * Get shape of vad session
+     *
+     * Ex: [2, 1, 64]
+     */
+    private _getShape;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<VadService>;
+}
+
+declare class ConfigService {
+    private readonly _config;
+    /**
+     * Audio config
+     */
+    get audio(): _prabhjeet_me_wakeywakey.WakeyWakeyAudioConfig;
+    /**
+     * Onnx config
+     */
+    get onnx(): _prabhjeet_me_wakeywakey.WakeyWakeyOnnxConfig;
+    /**
+     * Orb config
+     */
+    get orb(): OrbConfig | undefined;
+    /**
+     * Throttle time
+     */
+    get throttleTime(): number | undefined;
+    /**
+     * Mode
+     */
+    get mode(): "DEFAULT" | "VOICE_CHAT" | undefined;
+    /**
+     * Base path of assets
+     */
+    get basePath(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigService>;
+}
+
+declare class EventService {
+    /**
+     * Fires when library loaded
+     */
+    readonly ready: Subject<void>;
+    /**
+     * Fires when there is a message to log
+     */
+    readonly log: Subject<string>;
+    /**
+     * Fires when there is an error
+     */
+    readonly exception: Subject<Error>;
+    /**
+     * Fires when speech is detected
+     */
+    readonly speech: Subject<SpeechEvent>;
+    /**
+     * Fires when wake word is detected
+     */
+    readonly wakeword: Subject<WakeWordEvent>;
+    /**
+     * Fires when recording starts (after wake word detection)
+     */
+    readonly recording: Subject<void>;
+    /**
+     * Fires silence is detected
+     */
+    readonly silence: Subject<SilenceEvent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EventService>;
+}
+
+declare class ModelService {
+    /**
+     * Inference session
+     */
+    private _inferenceSession;
+    /**
+     * Get melspectrogram inference session
+     */
+    get melSpectrogram(): InferenceSession;
+    /**
+     * Get embedding inference session
+     */
+    get embedding(): InferenceSession;
+    /**
+     * Get Silero VAD inference session
+     */
+    get sileroVAD(): InferenceSession;
+    /**
+     * Get wakeword inference session
+     */
+    get wakeword(): InferenceSession;
+    /**
+     * Set session instance
+     */
+    set session(sessions: Record<InferenceModels, InferenceSession | undefined>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ModelService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ModelService>;
+}
+
+declare class PipelineService {
+    /**
+     * Dependencies
+     */
+    private readonly _model;
+    private readonly MEL_WINDOW_SIZE;
+    private readonly MEL_HOP_SIZE;
+    private readonly EMBEDDING_COUNT;
+    private readonly FEATURE_DIM;
+    private readonly MEL_BINS;
+    /**
+     * Historical buffer of embeddings representing the last ~1-2 seconds of audio context.
+     * Initialized with empty (zero) vectors.
+     */
+    private readonly _embeddingQueue;
+    /**
+     * Buffer of calculated Mel Spectrogram frames waiting to be processed.
+     */
+    private readonly _melFrameQueue;
+    /**
+     * Main entry point: Processes a new chunk of audio and returns a detection score.
+     */
+    run(speech: SpeechEvent): Promise<number>;
+    /**
+     * STAGE 1: Converts raw audio samples into Mel Frequency bins.
+     */
+    private _generateMelSpectrogram;
+    /**
+     * STAGE 2: Extracts features (embeddings) from a window of Mel frames.
+     */
+    private _processWindowToEmbeddings;
+    /**
+     * STAGE 3: Final classification score based on temporal embedding sequence.
+     */
+    private _getWakeWordScore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipelineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PipelineService>;
+}
+
+declare class PlatformService {
+    private readonly _platform;
+    /**
+     * Is browser
+     */
+    get isBrowser(): boolean;
+    /**
+     * Is server
+     */
+    get isServer(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlatformService>;
+}
+
+/**
+ * Provide wakey wakey configuration
+ *
+ * @param config Wakey Wakey configuration
+ * @returns
+ */
+declare function provideWakeyWakey(config: Config): (typeof ConfigService | typeof EventService | typeof ModelService | typeof PipelineService | typeof MicrophoneService | typeof PlatformService | typeof SpeakerService | typeof SpeechRecognitionService | typeof VadService | typeof AudioService | i0.EnvironmentProviders | {
+    provide: i0.InjectionToken<Config>;
+    useValue: Config;
+})[];
+
+export { CONFIG as WAKEYWAKEY_CONFIG, AudioUtil as WakeyWakeyAudioUtil, WakeyWakeyComponent, provideWakeyWakey };
+export type { AudioConfig as WakeyWakeyAudioConfig, Config as WakeyWakeyConfig, OnnxConfig as WakeyWakeyOnnxConfig, SilenceEvent as WakeyWakeySilenceEvent, SpeechEvent as WakeyWakeySpeechEvent, WakeWordEvent as WakeyWakeyWordEvent };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@prabhjeet.me/wakeywakey",
+  "version": "1.0.0",
+  "repository": {
+    "url": "https://github.com/prabhjeet-me/WakeyWakey"
+  },
+  "peerDependencies": {
+    "@angular/common": "^20.3.0",
+    "@angular/core": "^20.3.0",
+    "onnxruntime-web": "^1.24.1",
+    "three": "^0.183.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/prabhjeet.me-wakeywakey.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/prabhjeet.me-wakeywakey.mjs"
+    }
+  }
+}