cacophony 0.1.2 → 0.1.4

package/package.json

@@ -1,26 +1,26 @@
-{
-  "name": "cacophony",
-  "version": "0.1.2",
-  "description": "Typescript audio library with caching",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "npm run clean && tsc --build",
-    "clean": "tsc --build --clean",
-    "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [
-    "audio",
-    "webaudio"
-  ],
-  "author": "Christopher Toth",
-  "license": "ISC",
-  "devDependencies": {
-    "standardized-audio-context-mock": "^9.6.29",
-    "typescript": "^5.1.6"
-  },
-  "dependencies": {
-    "standardized-audio-context": "^25.3.55"
-  }
-}
+{
+  "name": "cacophony",
+  "version": "0.1.4",
+  "description": "Typescript audio library with caching",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && tsc --build",
+    "clean": "tsc --build --clean",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "audio",
+    "webaudio"
+  ],
+  "author": "Christopher Toth",
+  "license": "ISC",
+  "devDependencies": {
+    "standardized-audio-context-mock": "^9.6.29",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "standardized-audio-context": "^25.3.55"
+  }
+}

package/src/cacophony.ts

@@ -21,6 +21,8 @@ export interface BaseSound {
     addFilter(filter: BiquadFilterNode): void;
     removeFilter(filter: BiquadFilterNode): void;
     moveTo(x: number, y: number, z: number): void;
+    volume: number;
+
     loop(loopCount?: LoopCount): LoopCount;
 }
 
@@ -68,7 +70,6 @@ export class Cacophony {
         return filter;
     }
 
-
     pause() {
         if ('suspend' in this.context) {
             this.context.suspend();
@@ -91,6 +92,14 @@ export class Cacophony {
         this.globalGainNode.gain.value = volume;
     }
 
+    get volume(): number {
+        return this.globalGainNode.gain.value;
+    }
+
+    set volume(volume: number) {
+        this.setGlobalVolume(volume);
+    }
+
     mute() {
         this.prevVolume = this.globalGainNode.gain.value;
         this.setGlobalVolume(0);
@@ -154,7 +163,7 @@ export class Sound extends FilterManager implements BaseSound {
 
     play(): Playback[] {
         const playback = this.preplay();
-        playback.forEach(p => p.source.start());
+        playback.forEach(p => p.source!.start());
         return playback;
     }
 
@@ -184,7 +193,7 @@ export class Sound extends FilterManager implements BaseSound {
             return this.loopCount;
         }
         this.loopCount = loopCount;
-        this.playbacks.forEach(p => p.source.loop = true);
+        this.playbacks.forEach(p => p.source!.loop = true);
         return this.loopCount;
     }
 
@@ -197,14 +206,22 @@ export class Sound extends FilterManager implements BaseSound {
         super.removeFilter(filter);
         this.playbacks.forEach(p => p.removeFilter(filter));
     }
-}
 
+    get volume(): number {
+        return this.globalGainNode.gain.value;
+    }
+
+    set volume(volume: number) {
+        this.globalGainNode.gain.value = volume;
+        this.playbacks.forEach(p => p.volume = volume);
+    }
+}
 
 class Playback extends FilterManager implements BaseSound {
     context: AudioContext;
-    source: AudioBufferSourceNode;
-    gainNode: GainNode;
-    panner: PannerNode;
+    source?: AudioBufferSourceNode;
+    gainNode?: GainNode;
+    panner?: PannerNode;
     loopCount: LoopCount = 0;
     currentLoop: number = 0;
     buffer: IAudioBuffer | null = null;
@@ -223,7 +240,6 @@ class Playback extends FilterManager implements BaseSound {
         source.start();
     }
 
-
     handleLoop(): void {
         if (this.loopCount === 'infinite' || this.currentLoop < this.loopCount) {
             this.currentLoop++;
@@ -234,35 +250,68 @@ class Playback extends FilterManager implements BaseSound {
     }
 
     play() {
+        if (!this.source) {
+            throw new Error('Cannot play a sound that has been cleaned up');
+        }
         this.source.start();
         return [this];
     }
 
+    get volume(): number {
+        if (!this.gainNode) {
+            throw new Error('Cannot get volume of a sound that has been cleaned up');
+        }
+        return this.gainNode.gain.value;
+    }
+
     set volume(v: number) {
+        if (!this.gainNode) {
+            throw new Error('Cannot set volume of a sound that has been cleaned up');
+        }
         this.gainNode.gain.value = v;
     }
 
-    fadeIn(time: number, FfadeType: FadeType = 'linear'): Promise<void> {
+    fadeIn(time: number, fadeType: FadeType = 'linear'): Promise<void> {
         return new Promise(resolve => {
-            // Setting the initial gain value to 0
-            this.gainNode.gain.setValueAtTime(0, this.context.currentTime);
-            switch (FfadeType) {
+            if (!this.gainNode) {
+                throw new Error('Cannot fade in a sound that has been cleaned up');
+            }
+
+            const initialVolume = this.gainNode.gain.value;
+            const targetVolume = 1; // Assuming the target volume after fade-in is 1 (full volume)
+
+            // Reset volume to 0 to start the fade-in process
+            this.gainNode.gain.value = 0;
+
+            switch (fadeType) {
                 case 'exponential':
-                    // Scheduling an exponential fade up
-                    this.gainNode.gain.exponentialRampToValueAtTime(1, this.context.currentTime + time);
+                    // Start at a low value (0.01) because exponentialRampToValueAtTime cannot ramp from 0
+                    this.gainNode.gain.setValueAtTime(0.01, this.context.currentTime);
+                    this.gainNode.gain.exponentialRampToValueAtTime(targetVolume, this.context.currentTime + time);
                     break;
                 case 'linear':
-                    // Scheduling a linear ramp to the target gain value over the given duration
-                    this.gainNode.gain.linearRampToValueAtTime(1, this.context.currentTime + time);
+                    this.gainNode.gain.linearRampToValueAtTime(targetVolume, this.context.currentTime + time);
+                    break;
             }
-            // Resolving the Promise after the fade-in time
-            setTimeout(() => resolve(), time * 1000);
+
+            // Resolve the Promise after the fade-in time
+            setTimeout(() => {
+                // Ensure the final volume is set to the target volume
+                if (!this.gainNode) {
+                    throw new Error('Cannot fade in a sound that has been cleaned up');
+                }
+                this.gainNode.gain.value = targetVolume;
+                resolve();
+            }, time * 1000);
         });
     }
 
     fadeOut(time: number, fadeType: FadeType = 'linear'): Promise<void> {
         return new Promise(resolve => {
             // Storing the current gain value
+            if (!this.gainNode) {
+                throw new Error('Cannot fade out a sound that has been cleaned up');
+            }
             const initialVolume = this.gainNode.gain.value;
             switch (fadeType) {
                 case 'exponential':
@@ -279,7 +328,23 @@ class Playback extends FilterManager implements BaseSound {
         });
     }
 
+    cleanup(): void {
+        if (this.source) {
+            this.source.disconnect();
+            this.source = undefined;
+        }
+        if (this.gainNode) {
+            this.gainNode.disconnect();
+            this.gainNode = undefined;
+        }
+        this.filters.forEach(filter => filter.disconnect());
+        this.filters = [];
+    }
+
     loop(loopCount?: LoopCount): LoopCount {
+        if (!this.source) {
+            throw new Error('Cannot loop a sound that has been cleaned up');
+        }
         if (loopCount === undefined) {
             return this.source.loop === true ? 'infinite' : 0;
         }
@@ -290,16 +355,25 @@ class Playback extends FilterManager implements BaseSound {
     }
 
     stop(): void {
+        if (!this.source) {
+            throw new Error('Cannot stop a sound that has been cleaned up');
+        }
         this.source.stop();
     }
 
     pause(): void {
+        if (!this.source) {
+            throw new Error('Cannot pause a sound that has been cleaned up');
+        }
         if ('suspend' in this.source.context) {
             this.source.context.suspend();
         }
-
     }
+
     resume(): void {
+        if (!this.source) {
+            throw new Error('Cannot resume a sound that has been cleaned up');
+        }
         if ('resume' in this.source.context) {
             this.source.context.resume();
         }
@@ -316,12 +390,18 @@ class Playback extends FilterManager implements BaseSound {
     }
 
     moveTo(x: number, y: number, z: number): void {
+        if (!this.panner) {
+            throw new Error('Cannot move a sound that has been cleaned up');
+        }
         this.panner.positionX.value = x;
         this.panner.positionY.value = y;
         this.panner.positionZ.value = z;
     }
 
     private refreshFilters(): void {
+        if (!this.source || !this.gainNode) {
+            throw new Error('Cannot update filters on a sound that has been cleaned up');
+        }
         let connection = this.source;
         this.source.disconnect();
         connection = this.applyFilters(connection);
@@ -391,5 +471,13 @@ export class Group implements BaseSound {
         this.sounds.forEach(sound => sound.moveTo(x, y, z));
     }
 
+    get volume(): number {
+        return this.sounds[0].volume;
+    }
+
+    set volume(volume: number) {
+        this.sounds.forEach(sound => sound.volume = volume);
+    }
+
 }
 

package/src/cacophony.test.ts

@@ -1,5 +0,0 @@
-import { AudioBuffer, AudioContext, registrar } from 'standardized-audio-context-mock';
-
-import { Cacophony } from './cacophony';
-
-