+++ /dev/null
-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;
-}
projects / dotfiles / .git / blobdiff