hume 0.15.8 → 0.15.9

package/dist/esm/wrapper/SilenceFiller.mjs

@@ -1,10 +1,12 @@
-import { Readable } from "stream";
 /**
- * SilenceFiller is a Readable stream that intersperses incoming audio data
+ * SilenceFiller is a pipeable stream that intersperses incoming audio data
  * with bytes of silence. This is important in some cases to keep an audio
  * stream "alive". Audio players, such as ffmpeg, can interpret inactivity as
  * meaning the stream is ended, or disconnected.
  *
+ * This implementation does not depend on Node.js built-ins and can work in
+ * any JavaScript environment, while still being pipeable to Node.js streams.
+ *
  * @example
  * ```typescript
  * import { SilenceFiller } from 'hume';
@@ -29,7 +31,7 @@ import { Readable } from "stream";
  * await silenceFiller.endStream();
  * ```
  */
-export class SilenceFiller extends Readable {
+export class SilenceFiller {
     /**
      * Creates a new SilenceFiller instance.
      *
@@ -41,17 +43,90 @@ export class SilenceFiller extends Readable {
      * playback will take longer to start.
      */
     constructor(pushIntervalMs = 5, sampleRate = 48000, bytesPerSample = 2, bufferSize = 9600) {
-        super({ objectMode: false });
         this.isStarted = false;
-        this.pushInterval = null;
+        this.pushIntervalId = null;
+        this.destination = null;
+        this.eventListeners = new Map();
+        this.ended = false;
         this.unclockedSilenceFiller = new UnclockedSilenceFiller(bufferSize, sampleRate, bytesPerSample);
         this.bytesPerSample = bytesPerSample;
         this.pushIntervalMs = pushIntervalMs;
     }
+    /**
+     * Pipes the output of this SilenceFiller to a writable destination.
+     *
+     * @param destination - The destination to pipe to (e.g., a Node.js Writable stream).
+     * @returns The destination, for chaining.
+     */
+    pipe(destination) {
+        this.destination = destination;
+        return destination;
+    }
+    /**
+     * Registers an event listener.
+     *
+     * @param event - The event name ('error', 'end').
+     * @param listener - The listener function.
+     * @returns This instance, for chaining.
+     */
+    on(event, listener) {
+        if (!this.eventListeners.has(event)) {
+            this.eventListeners.set(event, new Set());
+        }
+        this.eventListeners.get(event).add(listener);
+        return this;
+    }
+    /**
+     * Registers a one-time event listener.
+     *
+     * @param event - The event name ('error', 'end').
+     * @param listener - The listener function.
+     * @returns This instance, for chaining.
+     */
+    once(event, listener) {
+        const onceWrapper = (...args) => {
+            this.off(event, onceWrapper);
+            listener(...args);
+        };
+        return this.on(event, onceWrapper);
+    }
+    /**
+     * Removes an event listener.
+     *
+     * @param event - The event name.
+     * @param listener - The listener function to remove.
+     * @returns This instance, for chaining.
+     */
+    off(event, listener) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
+        return this;
+    }
+    /**
+     * Emits an event to all registered listeners.
+     *
+     * @param event - The event name.
+     * @param args - Arguments to pass to listeners.
+     */
+    emit(event, ...args) {
+        const listeners = this.eventListeners.get(event);
+        if (listeners) {
+            for (const listener of listeners) {
+                try {
+                    listener(...args);
+                }
+                catch (_a) {
+                    // Ignore errors in listeners
+                }
+            }
+        }
+    }
     /**
      * Writes audio data to the silence filler.
      *
-     * @param audioBuffer - The audio buffer to write.
+     * @param audioBuffer - The audio buffer to write (Uint8Array or Buffer).
      */
     writeAudio(audioBuffer) {
         const now = Date.now();
@@ -68,12 +143,12 @@ export class SilenceFiller extends Readable {
         }
     }
     startPushInterval() {
-        this.pushInterval = setInterval(() => {
+        this.pushIntervalId = setInterval(() => {
             this.pushData();
         }, this.pushIntervalMs);
     }
     pushData() {
-        if (!this.isStarted)
+        if (!this.isStarted || !this.destination)
             return;
         try {
             const now = Date.now();
@@ -83,7 +158,7 @@ export class SilenceFiller extends Readable {
                 const alignedChunkSize = Math.floor(audioChunk.length / this.bytesPerSample) * this.bytesPerSample;
                 if (alignedChunkSize > 0) {
                     const chunk = audioChunk.subarray(0, alignedChunkSize);
-                    this.push(chunk);
+                    this.destination.write(chunk);
                 }
             }
         }
@@ -92,10 +167,6 @@ export class SilenceFiller extends Readable {
             this.emit("error", error);
         }
     }
-    _read() { }
-    _destroy(error, callback) {
-        super._destroy(error, callback);
-    }
     /**
      * Ends the stream and drains all remaining audio data.
      *
@@ -103,15 +174,20 @@ export class SilenceFiller extends Readable {
      */
     endStream() {
         return new Promise((resolve) => {
+            if (this.ended) {
+                resolve();
+                return;
+            }
+            this.ended = true;
             // Stop pushing data
-            if (this.pushInterval) {
-                clearInterval(this.pushInterval);
-                this.pushInterval = null;
+            if (this.pushIntervalId) {
+                clearInterval(this.pushIntervalId);
+                this.pushIntervalId = null;
             }
             // Drain all remaining audio from SilenceFiller
             const now = Date.now();
             // Keep reading until no more audio is available
-            while (true) {
+            while (this.destination) {
                 const remainingChunk = this.unclockedSilenceFiller.readAudio(now);
                 if (!remainingChunk || remainingChunk.length === 0) {
                     break;
@@ -119,13 +195,11 @@ export class SilenceFiller extends Readable {
                 const alignedChunkSize = Math.floor(remainingChunk.length / this.bytesPerSample) * this.bytesPerSample;
                 if (alignedChunkSize > 0) {
                     const chunk = remainingChunk.subarray(0, alignedChunkSize);
-                    this.push(chunk);
+                    this.destination.write(chunk);
                 }
             }
-            this.push(null); // Signal end of stream
-            this.once("end", () => {
-                resolve();
-            });
+            this.emit("end");
+            resolve();
         });
     }
 }
@@ -172,11 +246,11 @@ export class UnclockedSilenceFiller {
         if (alignedBytesNeeded <= 0) {
             return null;
         }
-        let chunk = Buffer.alloc(0);
+        let chunk = new Uint8Array(0);
         // Drain from queue until we have enough bytes
         while (chunk.length < alignedBytesNeeded && this.audioQueue.length > 0) {
             const nextBuffer = this.audioQueue.shift();
-            chunk = Buffer.concat([chunk, nextBuffer]);
+            chunk = concatUint8Arrays(chunk, nextBuffer);
             this.totalBufferedBytes -= nextBuffer.length;
         }
         // If we have more than needed, put the excess back
@@ -188,11 +262,20 @@ export class UnclockedSilenceFiller {
         }
         // Fill remaining with silence if needed
         if (chunk.length < alignedBytesNeeded) {
-            const silenceNeeded = Buffer.alloc(alignedBytesNeeded - chunk.length, 0);
-            chunk = Buffer.concat([chunk, silenceNeeded]);
+            const silenceNeeded = new Uint8Array(alignedBytesNeeded - chunk.length); // Uint8Array is zero-filled by default
+            chunk = concatUint8Arrays(chunk, silenceNeeded);
         }
         // Update total bytes sent
         this.totalBytesSent += chunk.length;
         return chunk;
     }
 }
+/**
+ * Concatenates two Uint8Arrays into a new Uint8Array.
+ */
+function concatUint8Arrays(a, b) {
+    const result = new Uint8Array(a.length + b.length);
+    result.set(a, 0);
+    result.set(b, a.length);
+    return result;
+}

package/dist/esm/wrapper/index.d.mts

@@ -12,4 +12,9 @@ export { ExpressionMeasurement } from "./expressionMeasurement/ExpressionMeasure
 export { EVIWebAudioPlayer } from "./EVIWebAudioPlayer.mjs";
 export type { EVIWebAudioPlayerFFTOptions, EVIWebAudioPlayerOptions } from "./EVIWebAudioPlayer.mjs";
 export { collate } from "./collate.mjs";
+export { SilenceFiller } from "./SilenceFiller.mjs";
+export type { PipeDestination } from "./SilenceFiller.mjs";
+/**
+ * @deprecated SilenceFiller no longer requires dynamic import. Use `import { SilenceFiller } from 'hume'` directly.
+ */
 export declare const createSilenceFiller: () => Promise<typeof import("./SilenceFiller.mjs").SilenceFiller>;

package/dist/esm/wrapper/index.mjs

@@ -20,12 +20,11 @@ export { HumeClient } from "./HumeClient.mjs";
 export { ExpressionMeasurement } from "./expressionMeasurement/ExpressionMeasurementClient.mjs";
 export { EVIWebAudioPlayer } from "./EVIWebAudioPlayer.mjs";
 export { collate } from "./collate.mjs";
-// SilenceFiller extends from Node.JS Readable -- this should not be exported in non-nodeJS environments. Otherwise the bundle will crash in the browser.
+export { SilenceFiller } from "./SilenceFiller.mjs";
+/**
+ * @deprecated SilenceFiller no longer requires dynamic import. Use `import { SilenceFiller } from 'hume'` directly.
+ */
 export const createSilenceFiller = () => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    if (typeof process === "undefined" || !((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node)) {
-        throw new Error("SilenceFiller is only available in Node.js environments");
-    }
     const { SilenceFiller } = yield import("./SilenceFiller.mjs");
     return SilenceFiller;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "hume",
-    "version": "0.15.8",
+    "version": "0.15.9",
     "private": false,
     "repository": "github:humeai/hume-typescript-sdk",
     "type": "commonjs",