fix(bindCallback): resulting function now recreated underlying Subjec…

…t and is reusable once again. (#6369)

* test: add failing tests

* fix(bindCallback): create subject within factory

spec/observables/bindCallback-spec.ts

@@ -126,6 +126,29 @@ describe('bindCallback', () => {
         done();
       });
     });
+
+    it('should create a separate internal subject for each call', () => {
+      function callback(datum: number, cb: (result: number) => void) {
+        cb(datum);
+      }
+      const boundCallback = bindCallback(callback);
+      const results: Array<string|number> = [];
+
+      boundCallback(42)
+        .subscribe(x => {
+          results.push(x);
+        }, null, () => {
+          results.push('done');
+        });
+      boundCallback(54)
+        .subscribe(x => {
+          results.push(x);
+        }, null, () => {
+          results.push('done');
+        });
+
+      expect(results).to.deep.equal([42, 'done', 54, 'done']);
+    });
   });
 
   describe('when scheduled', () => {

spec/observables/bindNodeCallback-spec.ts

@@ -124,6 +124,29 @@ describe('bindNodeCallback', () => {
         done();
       });
     });
+
+    it('should create a separate internal subject for each call', () => {
+      function callback(datum: number, cb: (err: any, n: number) => void) {
+        cb(null, datum);
+      }
+      const boundCallback = bindNodeCallback(callback);
+      const results: Array<number | string> = [];
+
+      boundCallback(42)
+        .subscribe(x => {
+          results.push(x);
+        }, null, () => {
+          results.push('done');
+        });
+      boundCallback(54)
+        .subscribe(x => {
+          results.push(x);
+        }, null, () => {
+          results.push('done');
+        });
+
+      expect(results).to.deep.equal([42, 'done', 54, 'done']);
+    });
   });
 
   describe('when scheduled', () => {

src/internal/observable/bindCallbackInternals.ts

@@ -35,11 +35,11 @@ export function bindCallbackInternals(
     };
   }
 
-  // We're using AsyncSubject, because it emits when it completes,
-  // and it will play the value to all late-arriving subscribers.
-  const subject = new AsyncSubject<any>();
-
   return function (this: any, ...args: any[]): Observable<any> {
+    // We're using AsyncSubject, because it emits when it completes,
+    // and it will play the value to all late-arriving subscribers.
+    const subject = new AsyncSubject<any>();
+
     // If this is true, then we haven't called our function yet.
     let uninitialized = true;
     return new Observable((subscriber) => {