feat(audio-decoder): add validation for sampleRate and numberOfChannels

Add positive integer validation for AudioDecoder.configure() to comply
with W3C WebCodecs spec requirement that unsigned long values must be
positive integers.

Validation:
- sampleRate must be > 0 (throws TypeError if zero or negative)
- numberOfChannels must be > 0 (throws TypeError if zero or negative)

Tests:
- Add edge case tests for zero/negative values
- Add tests for missing required fields
- Add test for whitespace-only codec string

Aligns with W3C spec: unsigned long requires positive integer values.

Author: pproenca

lib/audio-decoder.ts

@@ -77,6 +77,10 @@ export class AudioDecoder extends CodecBase {
       throw new TypeError('config.codec cannot be empty');
     }
 
+    // Validate positive values (W3C spec: unsigned long requires positive integer)
+    is.assertPositiveInteger(config.sampleRate, 'config.sampleRate');
+    is.assertPositiveInteger(config.numberOfChannels, 'config.numberOfChannels');
+
     this._needsKeyFrame = true;
     // Configure synchronously to set state immediately per W3C spec
     this._native.configure(config);

test/unit/audio-decoder-methods.test.ts

@@ -115,6 +115,75 @@ describe('AudioDecoder Methods: 3.5', () => {
         );
         decoder.close();
       });
+
+      it('should throw TypeError for whitespace-only codec', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => decoder.configure({ codec: '   ', sampleRate: 48000, numberOfChannels: 2 }),
+          TypeError,
+        );
+        decoder.close();
+      });
+
+      it('should throw TypeError for missing sampleRate', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => {
+            // @ts-expect-error Testing invalid input
+            decoder.configure({ codec: 'opus', numberOfChannels: 2 });
+          },
+          TypeError,
+        );
+        decoder.close();
+      });
+
+      it('should throw TypeError for missing numberOfChannels', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => {
+            // @ts-expect-error Testing invalid input
+            decoder.configure({ codec: 'opus', sampleRate: 48000 });
+          },
+          TypeError,
+        );
+        decoder.close();
+      });
+
+      it('should throw TypeError for zero sampleRate', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => decoder.configure({ codec: 'opus', sampleRate: 0, numberOfChannels: 2 }),
+          TypeError,
+        );
+        decoder.close();
+      });
+
+      it('should throw TypeError for negative sampleRate', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => decoder.configure({ codec: 'opus', sampleRate: -48000, numberOfChannels: 2 }),
+          TypeError,
+        );
+        decoder.close();
+      });
+
+      it('should throw TypeError for zero numberOfChannels', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => decoder.configure({ codec: 'opus', sampleRate: 48000, numberOfChannels: 0 }),
+          TypeError,
+        );
+        decoder.close();
+      });
+
+      it('should throw TypeError for negative numberOfChannels', () => {
+        const decoder = createDecoder();
+        assert.throws(
+          () => decoder.configure({ codec: 'opus', sampleRate: 48000, numberOfChannels: -2 }),
+          TypeError,
+        );
+        decoder.close();
+      });
     });
   });