Simplify SignalGrouping

src/lib/utils/SignalGrouping.ts

@@ -1,43 +1,39 @@
 namespace SignalGrouping {
-    export class Group<S extends QSignal<any>[]> {
-        private signalManager: SignalManager;
-        private argsBySignal: Map<S[number], GroupUnion<S>> = new Map();
+    export class Group {
+        private argsBySignal: Map<QSignal<[any]>, [[any]]> = new Map();
         private delayer = new Delayer(50, () => this.fire());
 
         constructor(
-            private handlers: Handler<S>[], // in order of decreasing priority
-        ) {
-            this.signalManager = new SignalManager();
-            const signals = collectSignals(handlers);
+            private handlers: Handler<any>[], // in order of decreasing priority
+        ) {}
+
+        public connect(manager: SignalManager) {
+            const signals = collectSignals(this.handlers);
             for (const signal of signals) {
-                this.signalManager.connect(signal, (...args: any) => {
+                manager.connect(signal, (...args: any) => {
                     this.argsBySignal.set(signal, args);
                     this.delayer.run();
                 });
             }
         }
 
-        public fire() {
+        private fire() {
             for (const handler of this.handlers) {
                 const args = this.getGroupArgs(handler.signals);
                 if (args !== null) {
-                    handler.f(...args);
+                    handler.f(args);
                     break;
                 }
             }
             this.argsBySignal.clear();
         }
 
-        public destroy() {
-            this.signalManager.destroy();
-        }
-
-        private getGroupArgs(signals: [...S]) {
+        private getGroupArgs(signals: QSignal<[any]>[]) {
             const groupArgs = signals.map(signal => this.argsBySignal.get(signal));
             if (groupArgs.some(args => args === undefined)) {
                 return null;
             }
-            return groupArgs as [...GroupArgs<S>];
+            return groupArgs;
         }
     }
 
@@ -53,14 +49,14 @@ namespace SignalGrouping {
         return signals;
     }
 
-    interface Handler<S extends QSignal<any>[]> {
-        signals: [...S];
-        f: (...args: [...GroupArgs<S>]) => void;
+    export class Handler<S extends QSignal<any>[]> {
+        constructor(
+            public signals: [...S],
+            public f: (...args: [...GroupArgs<S>]) => void,
+        ) {}
     }
 
     type GroupArgs<S extends QSignal<any>[]> = {
         [K in keyof S]: S[K] extends QSignal<infer A> ? A : never;
     };
-
-    type GroupUnion<S extends QSignal<any>[]> = S[number] extends QSignal<infer A> ? A : never;
 }