eliminate deprecated rx packages

package.json

@@ -72,7 +72,6 @@
     "mkdirp": "^0.5.1",
     "open": "*",
     "request-light": "^0.2.0",
-    "rx": "^4.1.0",
     "rxjs": "^5.5.6",
     "semver": "*",
     "tmp": "0.0.33",
@@ -94,7 +93,6 @@
     "@types/mkdirp": "^0.5.2",
     "@types/mocha": "^2.2.48",
     "@types/node": "^9.4.7",
-    "@types/rx": "^4.1.1",
     "@types/semver": "^5.5.0",
     "@types/tmp": "0.0.33",
     "async-child-process": "^1.1.1",

src/CompositeDisposable.ts

@@ -0,0 +1,41 @@
+/*--------------------------------------------------------------------------------------------- 
+ *  Copyright (c) Microsoft Corporation. All rights reserved. 
+ *  Licensed under the MIT License. See License.txt in the project root for license information. 
+ *--------------------------------------------------------------------------------------------*/ 
+
+import { Subscription } from "rxjs/Subscription"; 
+import Disposable from "./Disposable"; 
+
+export default class CompositeDisposable extends Disposable { 
+    private disposables = new Subscription(); 
+
+    constructor (...disposables: Disposable[]){ 
+        super(() => this.disposables.unsubscribe()); 
+
+        if (!disposables || disposables.length < 1) { 
+            throw new Error("disposables cannot be null or empty."); 
+        } 
+
+        for (const disposable of disposables) { 
+            if (disposable) { 
+                this.disposables.add(disposable.dispose); 
+            } 
+            else { 
+                throw new Error("null disposables are not supported"); 
+            } 
+        } 
+    } 
+
+    public add(disposable: Disposable | {(): void}) { 
+        if (!disposable) { 
+            throw new Error("disposable cannot be null"); 
+        } 
+
+        const actualDisposable =  
+            disposable.constructor.name === Disposable.name 
+                ? <Disposable>disposable 
+                : new Disposable(<{(): void}>disposable); 
+
+        this.disposables.add(actualDisposable.dispose); 
+    } 
+}

src/Disposable.ts

@@ -0,0 +1,20 @@
+/*--------------------------------------------------------------------------------------------- 
+ *  Copyright (c) Microsoft Corporation. All rights reserved. 
+ *  Licensed under the MIT License. See License.txt in the project root for license information. 
+ *--------------------------------------------------------------------------------------------*/ 
+
+export default class Disposable { 
+    private onDispose: {(): void}; 
+
+    constructor (onDispose: {(): void}){ 
+        if (!onDispose) { 
+            throw new Error("onDispose cannot be null or empty."); 
+        } 
+
+        this.onDispose = onDispose; 
+    } 
+
+    public dispose(): void { 
+        this.onDispose(); 
+    } 
+}

src/observers/WarningMessageObserver.ts

@@ -4,8 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { MessageItem, vscode } from '../vscodeAdapter';
-import { Scheduler, Subject } from 'rx';
 import { BaseEvent, OmnisharpServerOnError, OmnisharpServerMsBuildProjectDiagnostics } from "../omnisharp/loggingEvents";
+import { Scheduler } from 'rxjs/scheduler';
+import { Subject } from 'rxjs/Subject';
+import 'rxjs/add/operator/debounceTime';
 
 export interface MessageItemWithCommand extends MessageItem {
     command: string;
@@ -16,7 +18,7 @@ export class WarningMessageObserver {
 
     constructor(private vscode: vscode, scheduler?: Scheduler) {
         this.warningMessageDebouncer = new Subject<BaseEvent>();
-        this.warningMessageDebouncer.debounce(1500, scheduler).subscribe(async event => {
+        this.warningMessageDebouncer.debounceTime(1500, scheduler).subscribe(async event => {
             let message = "Some projects have trouble loading. Please review the output for more details.";
             let value = await this.vscode.window.showWarningMessage<MessageItemWithCommand>(message, { title: "Show Output", command: 'o.showOutput' });
             if (value) {
@@ -28,7 +30,7 @@ export class WarningMessageObserver {
     public post = (event: BaseEvent) => {
         switch (event.constructor.name) {
             case OmnisharpServerOnError.name:
-                this.warningMessageDebouncer.onNext(event);
+                this.warningMessageDebouncer.next(event);
                 break;
             case OmnisharpServerMsBuildProjectDiagnostics.name:
                 this.handleOmnisharpServerMsBuildProjectDiagnostics(<OmnisharpServerMsBuildProjectDiagnostics>event);
@@ -38,7 +40,7 @@ export class WarningMessageObserver {
 
     private handleOmnisharpServerMsBuildProjectDiagnostics(event: OmnisharpServerMsBuildProjectDiagnostics) {
         if (event.diagnostics.Errors.length > 0) {
-            this.warningMessageDebouncer.onNext(event);
+            this.warningMessageDebouncer.next(event);
         }
     }
 }

src/omnisharp/server.ts

@@ -23,7 +23,10 @@ import { setTimeout } from 'timers';
 import { OmnisharpDownloader } from './OmnisharpDownloader';
 import * as ObservableEvents from './loggingEvents';
 import { EventStream } from '../EventStream';
-import { Disposable, CompositeDisposable, Subject } from 'rx';
+import { Subject } from 'rxjs/Subject'; 
+import 'rxjs/add/operator/debounceTime';
+import CompositeDisposable from '../CompositeDisposable';
+import Disposable from '../Disposable';
 
 enum ServerState {
     Starting,
@@ -93,7 +96,7 @@ export class OmniSharpServer {
         this._requestQueue = new RequestQueueCollection(this.eventStream, 8, request => this._makeRequest(request));
         let downloader = new OmnisharpDownloader(this.eventStream, packageJSON, platformInfo);
         this._omnisharpManager = new OmnisharpManager(downloader, platformInfo);
-        this.updateProjectDebouncer.debounce(1500).subscribe((event) => { this.updateProjectInfo(); });
+        this.updateProjectDebouncer.debounceTime(1500).subscribe((event) => { this.updateProjectInfo(); });
         this.firstUpdateProject = true;
     }
 
@@ -226,7 +229,7 @@ export class OmniSharpServer {
     private _addListener(event: string, listener: (e: any) => any, thisArg?: any): Disposable {
         listener = thisArg ? listener.bind(thisArg) : listener;
         this._eventBus.addListener(event, listener);
-        return Disposable.create(() => this._eventBus.removeListener(event, listener));
+        return new Disposable(() => this._eventBus.removeListener(event, listener));
     }
 
     protected _fireEvent(event: string, args: any): void {
@@ -348,7 +351,7 @@ export class OmniSharpServer {
             this.updateProjectInfo();
         }
         else {
-            this.updateProjectDebouncer.onNext(new ObservableEvents.ProjectModified());
+            this.updateProjectDebouncer.next(new ObservableEvents.ProjectModified());
         }
     }
 
@@ -545,7 +548,7 @@ export class OmniSharpServer {
 
         this._readLine.addListener('line', lineReceived);
 
-        this._disposables.add(Disposable.create(() => {
+        this._disposables.add(new Disposable(() => {
             this._readLine.removeListener('line', lineReceived);
         }));
 

test/unitTests/logging/InformationMessageObserver.test.ts

@@ -3,11 +3,13 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as rx from 'rx';
 import { InformationMessageObserver } from '../../../src/observers/InformationMessageObserver';
 import { use as chaiUse, expect, should } from 'chai';
 import { vscode, Uri } from '../../../src/vscodeAdapter';
 import { getFakeVsCode, getNullWorkspaceConfiguration, getUnresolvedDependenices } from './Fakes';
+import { Observable } from 'rxjs/Observable';
+import 'rxjs/add/observable/fromPromise';
+import 'rxjs/add/operator/timeout';
 
 chaiUse(require('chai-as-promised'));
 chaiUse(require('chai-string'));
@@ -112,7 +114,7 @@ suite("InformationMessageObserver", () => {
             test('Given an information message if the user clicks cancel, the command is not executed', async () => {
                 observer.post(event);
                 doClickCancel();
-                await expect(rx.Observable.fromPromise(commandDone).timeout(1).toPromise()).to.be.rejected;
+                await expect(Observable.fromPromise(commandDone).timeout(1).toPromise()).to.be.rejected;
                 expect(invokedCommand).to.be.undefined;
             });
         });   

test/unitTests/logging/WarningMessageObserver.test.ts

@@ -3,13 +3,14 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as rx from 'rx';
 import { WarningMessageObserver } from '../../../src/observers/WarningMessageObserver';
-import { use as chaiUse, expect, should } from 'chai';
+import { assert, use as chaiUse, expect, should } from 'chai';
 import { getFakeVsCode, getMSBuildDiagnosticsMessage, getOmnisharpMSBuildProjectDiagnosticsEvent, getOmnisharpServerOnErrorEvent } from './Fakes';
 import { BaseEvent } from '../../../src/omnisharp/loggingEvents';
 import { vscode } from '../../../src/vscodeAdapter';
-import { Observable } from 'rx';
+import { TestScheduler } from 'rxjs/testing/TestScheduler';
+import { Observable } from 'rxjs/Observable';
+import 'rxjs/add/observable/fromPromise';
 
 chaiUse(require('chai-as-promised'));
 chaiUse(require('chai-string'));
@@ -26,7 +27,7 @@ suite('WarningMessageObserver', () => {
 
     let warningMessage: string;
     let invokedCommand: string;
-    let scheduler: rx.HistoricalScheduler;
+    let scheduler: TestScheduler;
     let observer: WarningMessageObserver;
     let vscode: vscode = getFakeVsCode();
 
@@ -51,9 +52,7 @@ suite('WarningMessageObserver', () => {
     };
 
     setup(() => {
-        scheduler = new rx.HistoricalScheduler(0, (x, y) => {
-            return x > y ? 1 : -1;
-        });
+        scheduler = new TestScheduler(assert.deepEqual);
         observer = new WarningMessageObserver(vscode, scheduler);
         warningMessage = undefined;
         invokedCommand = undefined;