refactor(synth): Signal.toggle

Author: Picalines

packages/synth/src/node/constant/constant-synth-node.ts

@@ -19,6 +19,10 @@ export class ConstantSynthNode extends SynthNode {
       automate: { param: constantSource.offset },
     })
 
-    constantSource.start()
+    synth.playing.toggle(
+      this.disposed,
+      () => constantSource.start(),
+      () => constantSource.stop(),
+    )
   }
 }

packages/synth/src/node/generator/generator-synth-node.ts

@@ -125,23 +125,30 @@ export class GeneratorSynthNode extends SynthNode {
       updateWaveShape()
       this.waveShape.changed.watch(updateWaveShape)
 
-      oscillator.start()
-      this.disposed.watch(() => oscillator.stop())
+      synth.playing.toggle(
+        this.disposed,
+        () => oscillator.start(),
+        () => oscillator.stop(),
+      )
 
       return { frequency, adsr }
     })
 
-    const mute = () => {
-      master.gain.value = 0
-    }
-
-    const unmute = () => {
-      master.gain.value = DEFAULT_SOURCE_GAIN
-    }
-
-    mute()
-    this.synth.playing.watchUntil(this.disposed, unmute)
-    this.synth.stopped.watchUntil(this.disposed, mute)
+    // this.synth.playing.watch(() => console.log('playing'))
+    // this.synth.stopped.watch(() => console.log('stopped'))
+
+    master.gain.value = 0
+    this.synth.playing.toggle(
+      this.synth.stopped,
+      () => {
+        // console.log('master on')
+        master.gain.value = DEFAULT_SOURCE_GAIN
+      },
+      () => {
+        // console.log('master off')
+        master.gain.value = 0
+      },
+    )
   }
 
   attackAt(time: Time, frequency: Hertz) {

packages/synth/src/node/oscillator/oscillator-synth-node.ts

@@ -22,8 +22,6 @@ export class OscillatorSynthNode extends SynthNode {
     oscillator.connect(merger, 0, 1)
     merger.connect(master)
 
-    oscillator.start()
-
     super({ synth, inputs: [], outputs: [master] })
 
     this.waveShape = new EnumSynthParam({
@@ -46,19 +44,21 @@ export class OscillatorSynthNode extends SynthNode {
       automate: { param: oscillator.frequency },
     })
 
-    const unmuteOscillator = () => {
-      master.gain.value = DEFAULT_SOURCE_GAIN
-    }
-
-    const muteOscillator = () => {
-      master.gain.value = 0
-    }
-
-    muteOscillator()
-
-    this.synth.playing.watchUntil(this.disposed, unmuteOscillator)
-    this.synth.stopped.watchUntil(this.disposed, muteOscillator)
-
-    this.disposed.watch(() => oscillator.stop())
+    synth.playing.toggle(
+      this.disposed,
+      () => oscillator.start(),
+      () => oscillator.stop(),
+    )
+
+    master.gain.value = 0
+    synth.playing.toggle(
+      synth.stopped,
+      () => {
+        master.gain.value = DEFAULT_SOURCE_GAIN
+      },
+      () => {
+        master.gain.value = 0
+      },
+    )
   }
 }

packages/synth/src/signal/signal.ts

@@ -30,67 +30,88 @@ export class Signal<TParam> {
     }
   }
 
-  static combine<TParam>(signals: Signal<TParam>[]): Signal<TParam> {
-    const { signal, emit } = Signal.controlled<TParam>()
-
-    for (const parentSignal of signals) {
-      parentSignal.watch(emit)
-    }
-
-    return signal
-  }
-
   get emitted() {
     return this.#emitted
   }
 
+  get watched() {
+    return this.#listeners.length > 0
+  }
+
   watch(listener: (param: TParam) => void) {
-    if (this.#once && this.#emitted) {
-      return
+    if (this.#active) {
+      this.#listeners.push(listener)
     }
+  }
 
-    this.#listeners.push(listener)
+  cancel(listener: (param: TParam) => void) {
+    const index = this.#listeners.indexOf(listener)
+    if (index >= 0) {
+      this.#listeners.splice(index, 1)
+    }
   }
 
   watchUntil(cancelSignal: Signal<any>, listener: (param: TParam) => void) {
-    if ((cancelSignal.#once && cancelSignal.#emitted) || (this.#once && this.#emitted)) {
+    if (!this.#active || !cancelSignal.#active) {
       return
     }
 
+    const cancel = () => {
+      this.cancel(listener)
+      cancelSignal.cancel(cancel)
+    }
+
     this.watch(listener)
-    cancelSignal.watch(() => this.cancel(listener))
+    cancelSignal.watch(cancel)
   }
 
-  chain(signal: SignalController<TParam>) {
-    this.watch(param => signal.emit(param))
-  }
+  toggle<TUndoParam>(
+    undoSignal: Signal<TUndoParam>,
+    applyListener: (param: TParam) => void,
+    undoListener: (param: TUndoParam) => void,
+  ) {
+    if (!this.#active || !undoSignal.#active) {
+      return
+    }
 
-  cancel(listener: (param: TParam) => void) {
-    const index = this.#listeners.indexOf(listener)
-    if (index >= 0) {
-      this.#listeners.splice(index, 1)
+    const apply = (param: TParam) => {
+      this.cancel(apply)
+      if (undoSignal.#active) {
+        applyListener(param)
+        undoSignal.watch(undo)
+      }
+    }
+
+    const undo = (param: TUndoParam) => {
+      undoSignal.cancel(undo)
+      undoListener(param)
+      if (this.#active) {
+        this.watch(apply)
+      }
     }
+
+    this.watch(apply)
+  }
+
+  get #active() {
+    return !(this.#once && this.#emitted)
   }
 
   #cancelAll() {
     this.#listeners.length = 0
   }
 
   #emit(param: TParam) {
-    if (this.#once && this.#emitted) {
+    if (!this.#active) {
       return
     }
 
     this.#emitted = true
 
-    if (this.#reverseOrder) {
-      for (let index = this.#listeners.length - 1; index >= 0; index--) {
-        this.#listeners[index]?.(param)
-      }
-    } else {
-      for (const listener of this.#listeners) {
-        listener(param)
-      }
+    const listeners = this.#reverseOrder ? this.#listeners.toReversed() : this.#listeners.slice()
+
+    for (const listener of listeners) {
+      listener(param)
     }
 
     if (this.#once) {