fix send, fix lost data before connect open, add example. (#49)

* change send returning from cold Observable to 3 mode
1(Direct) send and return true or false (false when socket is close)
2(Promise) send and return promise
3(Observable) send and return cold Observable

the default mode is 1(Direct).

and as soon as that, import bluebird

* change send returning from cold Observable to 3 mode
1(Direct) send and return true or false (false when socket is close)
2(Promise) send and return promise
3(Observable) send and return cold Observable

the default mode is 3(Observable).

and as soon as that, update compile target to es6 and import bluebird

* update typescript version to 2.1.1 to fix typescript server compile error on webstorm

* fix

* fix data lose when connect creating before connect open.
now you can connect and immediately send data!
the data will cache in local until connect create or lost, cached data will send in connect create immediately!
every connect close in not reconnect mode will clear cached data, but reconnect will not.

* enum change name

* add example

* small change

Author: Lyoko-Jeremie

README.md

@@ -23,4 +23,86 @@ ws.getDataStream() returns Subject<any> to which you can attach an Observer (htt
 npm run typings
 npm run compile
 
+```
+
+## example
+```ts
+import {$WebSocket, WebSocketSendMode} from 'angular2-websocket/angular2-websocket';
+  
+// connect
+var ws = new $WebSocket("ws://127.0.0.1:7000");
+// you can send immediately after connect, 
+// data will cached until connect open and immediately send or connect fail.
+  
+// when connect fail, websocket will reconnect or not,
+// you can set {WebSocketConfig.reconnectIfNotNormalClose = true} to enable auto reconnect
+// all cached data will lost when connect close if not reconnect
+  
+  
+// set received message callback
+ws.onMessage(
+    (msg: MessageEvent)=> {
+        console.log("onMessage ", msg.data);
+    },
+    {autoApply: false}
+);
+  
+// set received message stream
+ws.getDataStream().subscribe(
+    (msg)=> {
+        console.log("next", msg.data);
+        ws.close(false);
+    },
+    (msg)=> {
+        console.log("error", msg);
+    },
+    ()=> {
+        console.log("complete");
+    }
+);
+  
+// send with default send mode (now default send mode is Observer)
+ws.send("some thing").subscribe(
+        (msg)=> {
+            console.log("next", msg.data);
+        },
+        (msg)=> {
+            console.log("error", msg);
+        },
+        ()=> {
+            console.log("complete");
+        }
+    );
+  
+ws.send("by default, this will never be send, because Observer is cold.");
+ws.send("by default, this will be send, because Observer is hot.").publish().connect();
+  
+ws.setSendMode(WebSocketSendMode.Direct);
+ws.send("this will be send Direct, because send mode is set to Direct.");
+  
+ws.send("this will be send and return Promise.", WebSocketSendMode.Promise).then(
+        (T) => {
+            console.log("is send");
+        },
+        (T) => {
+            console.log("not send");
+        }
+    );
+  
+ws.send("this will be send and return Observer.").subscribe(
+        (msg)=> {
+            console.log("next", msg.data);
+        },
+        (msg)=> {
+            console.log("error", msg);
+        },
+        ()=> {
+            console.log("complete");
+        }
+    );
+
+ws.close(false);    // close
+ws.close(true);    // close immediately
+
+
 ```

angular2-websocket.d.ts

@@ -1,14 +1,10 @@
-import { Observable } from "rxjs/Observable";
-import { Subject } from "rxjs/Subject";
-export interface WebSocketConfig {
-    initialTimeout: number;
-    maxTimeout: number;
-    reconnectIfNotNormalClose: boolean;
-}
+import { Observable } from 'rxjs/Observable';
+import { Subject } from 'rxjs/Subject';
 export declare class $WebSocket {
     private url;
     private protocols;
     private config;
+    private static Helpers;
     private reconnectAttempts;
     private sendQueue;
     private onOpenCallbacks;
@@ -19,10 +15,48 @@ export declare class $WebSocket {
     private normalCloseCode;
     private reconnectableStatusCodes;
     private socket;
+    private dataStream;
     private internalConnectionState;
     constructor(url: string, protocols?: Array<string>, config?: WebSocketConfig);
     connect(force?: boolean): void;
-    static create(url: string, protocols: Array<string>): WebSocket;
+    /**
+     * Run in Block Mode
+     * Return true when can send and false in socket closed
+     * @param data
+     * @returns {boolean}
+     */
+    send4Direct(data: any): boolean;
+    /**
+     * Return Promise
+     * When can Send will resolve Promise
+     * When Socket closed will reject Promise
+     * @param data
+     * @returns {Promise<any>}
+     */
+    send4Promise(data: any): Promise<any>;
+    /**
+     * Return cold Observable
+     * When can Send will complete observer
+     * When Socket closed will error observer
+     * @param data
+     * @returns {Observable<any>}
+     */
+    send4Observable(data: any): Observable<any>;
+    private send4Mode;
+    /**
+     * Set send(data) function return mode
+     * @param mode
+     */
+    setSend4Mode(mode: WebSocketSendMode): void;
+    /**
+     * Use {mode} mode to send {data} data
+     * If no specify, Default SendMode is Observable mode
+     * @param data
+     * @param mode
+     * @returns {any}
+     */
+    send(data: any, mode?: WebSocketSendMode): any;
+    getDataStream(): Subject<any>;
     onOpenHandler(event: Event): void;
     notifyOpenCallbacks(event: any): void;
     fireQueue(): void;
@@ -31,16 +65,27 @@ export declare class $WebSocket {
     onOpen(cb: any): this;
     onClose(cb: any): this;
     onError(cb: any): this;
-    onMessage(callback: any, options: any): this;
+    onMessage(callback: any, options?: any): this;
     onMessageHandler(message: MessageEvent): void;
     onCloseHandler(event: CloseEvent): void;
     onErrorHandler(event: any): void;
-    send(data: any): Observable<any>;
     reconnect(): this;
-    close(force: boolean): this;
+    close(force?: boolean): this;
     getBackoffDelay(attempt: any): number;
     setInternalState(state: any): void;
+    /**
+     * Could be -1 if not initzialized yet
+     * @returns {number}
+     */
     getReadyState(): number;
-    setReadyState(): void;
-    getDataStream(): Subject<any>;
+}
+export interface WebSocketConfig {
+    initialTimeout: number;
+    maxTimeout: number;
+    reconnectIfNotNormalClose: boolean;
+}
+export declare enum WebSocketSendMode {
+    Direct = 0,
+    Promise = 1,
+    Observable = 2,
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "angular2-websocket",
   "main": "angular2-websocket",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "compile": "tsc",
@@ -10,24 +10,27 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/afrad/angular2-websocket.git"
+    "url": "git+https://github.com/Lyoko-Jeremie/angular2-websocket.git"
   },
   "dependencies": {
     "@angular/common": "~2.0.0",
     "@angular/compiler": "~2.0.0",
     "@angular/core": "~2.0.0",
+    "bluebird": "^3.4.6",
     "core-js": "^2.4.1",
     "reflect-metadata": "^0.1.8",
     "rxjs": "5.0.0-beta.12",
+    "typescript": "^2.1.1",
     "zone.js": "^0.6.25"
   },
   "devDependencies": {
+    "@types/bluebird": "^3.0.35",
     "codelyzer": "^1.0.0-beta.0",
     "grunt": "~0.4.1",
-    "grunt-typescript": "~0.2.4",
     "grunt-contrib-uglify": "~0.2.4",
+    "grunt-typescript": "~0.2.4",
     "tslint": "^3.15.1",
-    "typings": "^1.4.0",
-    "typescript": "^2.0.3"
+    "typescript": "^2.0.3",
+    "typings": "^1.4.0"
   }
 }