| import { Subject, AnonymousSubject } from '../../Subject'; |
| import { Subscriber } from '../../Subscriber'; |
| import { Observable } from '../../Observable'; |
| import { Subscription } from '../../Subscription'; |
| import { Operator } from '../../Operator'; |
| import { Observer, NextObserver } from '../../types'; |
| /** |
| * WebSocketSubjectConfig is a plain Object that allows us to make our |
| * webSocket configurable. |
| * |
| * <span class="informal">Provides flexibility to {@link webSocket}</span> |
| * |
| * It defines a set of properties to provide custom behavior in specific |
| * moments of the socket's lifecycle. When the connection opens we can |
| * use `openObserver`, when the connection is closed `closeObserver`, if we |
| * are interested in listening for data comming from server: `deserializer`, |
| * which allows us to customize the deserialization strategy of data before passing it |
| * to the socket client. By default `deserializer` is going to apply `JSON.parse` to each message comming |
| * from the Server. |
| * |
| * ## Example |
| * **deserializer**, the default for this property is `JSON.parse` but since there are just two options |
| * for incomming data, either be text or binarydata. We can apply a custom deserialization strategy |
| * or just simply skip the default behaviour. |
| * ```ts |
| * import { webSocket } from 'rxjs/webSocket'; |
| * |
| * const wsSubject = webSocket({ |
| * url: 'ws://localhost:8081', |
| * //Apply any transformation of your choice. |
| * deserializer: ({data}) => data |
| * }); |
| * |
| * wsSubject.subscribe(console.log); |
| * |
| * // Let's suppose we have this on the Server: ws.send("This is a msg from the server") |
| * //output |
| * // |
| * // This is a msg from the server |
| * ``` |
| * |
| * **serializer** allows us tom apply custom serialization strategy but for the outgoing messages |
| * ```ts |
| * import { webSocket } from 'rxjs/webSocket'; |
| * |
| * const wsSubject = webSocket({ |
| * url: 'ws://localhost:8081', |
| * //Apply any transformation of your choice. |
| * serializer: msg => JSON.stringify({channel: "webDevelopment", msg: msg}) |
| * }); |
| * |
| * wsSubject.subscribe(() => subject.next("msg to the server")); |
| * |
| * // Let's suppose we have this on the Server: ws.send("This is a msg from the server") |
| * //output |
| * // |
| * // {"channel":"webDevelopment","msg":"msg to the server"} |
| * ``` |
| * |
| * **closeObserver** allows us to set a custom error when an error raise up. |
| * ```ts |
| * import { webSocket } from 'rxjs/webSocket'; |
| * |
| * const wsSubject = webSocket({ |
| * url: 'ws://localhost:8081', |
| * closeObserver: { |
| next(closeEvent) { |
| const customError = { code: 6666, reason: "Custom evil reason" } |
| console.log(`code: ${customError.code}, reason: ${customError.reason}`); |
| } |
| } |
| * }); |
| * |
| * //output |
| * // code: 6666, reason: Custom evil reason |
| * ``` |
| * |
| * **openObserver**, Let's say we need to make some kind of init task before sending/receiving msgs to the |
| * webSocket or sending notification that the connection was successful, this is when |
| * openObserver is usefull for. |
| * ```ts |
| * import { webSocket } from 'rxjs/webSocket'; |
| * |
| * const wsSubject = webSocket({ |
| * url: 'ws://localhost:8081', |
| * openObserver: { |
| * next: () => { |
| * console.log('connetion ok'); |
| * } |
| * }, |
| * }); |
| * |
| * //output |
| * // connetion ok` |
| * ``` |
| * */ |
| export interface WebSocketSubjectConfig<T> { |
| /** The url of the socket server to connect to */ |
| url: string; |
| /** The protocol to use to connect */ |
| protocol?: string | Array<string>; |
| /** @deprecated use {@link deserializer} */ |
| resultSelector?: (e: MessageEvent) => T; |
| /** |
| * A serializer used to create messages from passed values before the |
| * messages are sent to the server. Defaults to JSON.stringify. |
| */ |
| serializer?: (value: T) => WebSocketMessage; |
| /** |
| * A deserializer used for messages arriving on the socket from the |
| * server. Defaults to JSON.parse. |
| */ |
| deserializer?: (e: MessageEvent) => T; |
| /** |
| * An Observer that watches when open events occur on the underlying web socket. |
| */ |
| openObserver?: NextObserver<Event>; |
| /** |
| * An Observer than watches when close events occur on the underlying webSocket |
| */ |
| closeObserver?: NextObserver<CloseEvent>; |
| /** |
| * An Observer that watches when a close is about to occur due to |
| * unsubscription. |
| */ |
| closingObserver?: NextObserver<void>; |
| /** |
| * A WebSocket constructor to use. This is useful for situations like using a |
| * WebSocket impl in Node (WebSocket is a DOM API), or for mocking a WebSocket |
| * for testing purposes |
| */ |
| WebSocketCtor?: { |
| new (url: string, protocols?: string | string[]): WebSocket; |
| }; |
| /** Sets the `binaryType` property of the underlying WebSocket. */ |
| binaryType?: 'blob' | 'arraybuffer'; |
| } |
| export declare type WebSocketMessage = string | ArrayBuffer | Blob | ArrayBufferView; |
| export declare class WebSocketSubject<T> extends AnonymousSubject<T> { |
| private _config; |
| /** @deprecated This is an internal implementation detail, do not use. */ |
| _output: Subject<T>; |
| private _socket; |
| constructor(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>); |
| lift<R>(operator: Operator<T, R>): WebSocketSubject<R>; |
| private _resetState; |
| /** |
| * Creates an {@link Observable}, that when subscribed to, sends a message, |
| * defined by the `subMsg` function, to the server over the socket to begin a |
| * subscription to data over that socket. Once data arrives, the |
| * `messageFilter` argument will be used to select the appropriate data for |
| * the resulting Observable. When teardown occurs, either due to |
| * unsubscription, completion or error, a message defined by the `unsubMsg` |
| * argument will be send to the server over the WebSocketSubject. |
| * |
| * @param subMsg A function to generate the subscription message to be sent to |
| * the server. This will still be processed by the serializer in the |
| * WebSocketSubject's config. (Which defaults to JSON serialization) |
| * @param unsubMsg A function to generate the unsubscription message to be |
| * sent to the server at teardown. This will still be processed by the |
| * serializer in the WebSocketSubject's config. |
| * @param messageFilter A predicate for selecting the appropriate messages |
| * from the server for the output stream. |
| */ |
| multiplex(subMsg: () => any, unsubMsg: () => any, messageFilter: (value: T) => boolean): Observable<any>; |
| private _connectSocket; |
| /** @deprecated This is an internal implementation detail, do not use. */ |
| _subscribe(subscriber: Subscriber<T>): Subscription; |
| unsubscribe(): void; |
| } |