rsocket-browser/dist/index.mjs.map

The RSocket client implementation over websocket with browser compatibility based on Uint8Array

{"version":3,"sources":["../src/connection/Connection.ts","../src/emitter/Emitter.ts"],"sourcesContent":["import {RSocket} from \"@/rsocket/RSocket\";\nimport {Flux, Mono, Schedulers, Sinks} from \"reactor-core-ts\";\nimport {\n    CancelFrame,\n    FireAndForgetFlag,\n    Frame,\n    FrameDeserializer,\n    FrameType,\n    KeepaliveFlag,\n    KeepaliveFrame,\n    Metadata,\n    MetadataPushFrame,\n    MimeType,\n    Payload,\n    PayloadFlag,\n    PayloadFrame,\n    RequestChannelFlag,\n    RequestChannelFrame,\n    RequestFireAndForgetFrame,\n    RequestNFrame,\n    RequestResponseFlag,\n    RequestResponseFrame,\n    RequestStreamFlag,\n    RequestStreamFrame,\n    SetupFlag,\n    SetupFrame\n} from \"rsocket-frames-ts\";\nimport {Emitter} from \"@/emitter/Emitter\";\n\nexport type ConnectionOptions<M, P> = {\n    url: string,\n    setup: {\n        keepAlive: number\n        lifetime: number\n        mimetype: {\n            metadata: MimeType<M>,\n            payload: MimeType<P>\n        }\n        version?: {\n            major?: number\n            minor?: number\n        }\n    }\n}\n\nexport class Connection<M, P> implements RSocket<M, P> {\n    protected readonly requests = new Emitter<Frame>()\n    protected readonly responses = new Emitter<Frame>()\n\n    public constructor(protected readonly options: ConnectionOptions<M, P>, metadata?: Mono<M>, payload?: Mono<P>) {\n        this.websocket()\n        this.setup(metadata, payload)\n        this.keepAlive()\n    }\n\n    private _streamId = -1\n\n    protected get streamId() {\n        return this._streamId += 2\n    }\n\n    public fireAndForget(metadata?: Mono<M>, payload?: Mono<P>): void {\n        this.normalize(metadata, payload)\n            .subscribe({\n                onNext: ({metadata, payload}) =>\n                    this.requests.next(new RequestFireAndForgetFrame(this.streamId, FireAndForgetFlag.NONE, metadata, payload))\n            })\n            .request(1)\n    }\n\n    public requestResponse<R>(metadata?: Mono<M>, payload?: Mono<P>): Mono<R> {\n        return this.normalize(metadata, payload)\n            .flatMap(({metadata, payload}) => {\n                const streamId = this.streamId\n                this.requests.next(new RequestResponseFrame(streamId, RequestResponseFlag.NONE, metadata, payload))\n                return Flux.from(this.responses)\n                    .filter(frame => frame.header.streamId == streamId)\n                    .mapNotNull(frame => frame.payload?.payload)\n                    .first()\n                    .cast<R>()\n            })\n    }\n\n    public requestStream<R>(metadata?: Mono<M>, payload?: Mono<P>): Flux<R> {\n        return this.normalize(metadata, payload)\n            .flatMapMany(({metadata, payload}) => {\n                const streamId = this.streamId\n                this.requests.next(new RequestStreamFrame(streamId, RequestStreamFlag.NONE, 0, metadata, payload))\n                const sink = Sinks.many().multicast<R>()\n                let completed = false\n                const server = Flux.from(this.responses)\n                    .filter(frame => ((frame.type == FrameType.PAYLOAD) || (frame.type == FrameType.CANCEL)) &&\n                        frame.header.streamId == streamId)\n                    .cast<PayloadFrame>()\n                    .subscribe({\n                        onNext: (frame: PayloadFrame) => {\n                            if (frame.type == FrameType.CANCEL) {\n                                server.unsubscribe()\n                                sink.complete()\n                            } else {\n                                if (frame.isNext()) {\n                                    const payload = frame.payload?.payload\n                                    if (payload != undefined) sink.next(payload)\n                                }\n                                if (frame.isComplete()) {\n                                    completed = true\n                                    sink.complete()\n                                }\n                            }\n                        },\n                        onComplete: () => {\n                            sink.complete()\n                        }\n                    })\n                return Flux.from(sink)\n                    .doOnSubscribe(subscription => {\n                        server.request(Number.MAX_SAFE_INTEGER)\n                        const request = subscription.request\n                        subscription.request = (count: number) => {\n                            request(count)\n                            this.requests.next(new RequestNFrame(streamId, count))\n                        }\n                        const unsubscribe = subscription.unsubscribe\n                        subscription.unsubscribe = () => {\n                            unsubscribe()\n                            if (!completed) this.requests.next(new CancelFrame(streamId))\n                            server.unsubscribe()\n                        }\n                    })\n            })\n    }\n\n    public requestChannel<R>(payloads: Flux<P>, metadata?: Mono<M>, payload?: Mono<P>): Flux<R> {\n        return this.normalize(metadata, payload)\n            .flatMapMany(({metadata, payload}) => {\n                const streamId = this.streamId\n                this.requests.next(new RequestChannelFrame(streamId, RequestChannelFlag.NONE, 0, metadata, payload))\n                // todo подумать как реализовать unsubscribe без complete\n                const client = payloads.subscribe({\n                    onNext: data => {\n                        this.requests.next(new PayloadFrame(streamId, PayloadFlag.NEXT, undefined, this.options.setup.mimetype.payload.toPayload(data)))\n                    },\n                    onComplete: () => {\n                        this.requests.next(new PayloadFrame(streamId, PayloadFlag.COMPLETE))\n                    }\n                })\n                const sink = Sinks.many().multicast<R>()\n                let completed = false\n                const server = Flux.from(this.responses)\n                    .filter(frame => ((frame.type == FrameType.CANCEL) ||\n                            (frame.type == FrameType.PAYLOAD) ||\n                            (frame.type == FrameType.REQUEST_N)) &&\n                        frame.header.streamId == streamId)\n                    .map(frame => {\n                        const payload = frame?.payload?.payload\n                        switch (frame.type) {\n                            case FrameType.PAYLOAD: {\n                                if (frame.isFlagSet(PayloadFlag.NEXT)) sink.next(payload)\n                                if (frame.isFlagSet(PayloadFlag.COMPLETE)) {\n                                    completed = true\n                                    sink.complete()\n                                }\n                                break\n                            }\n                            case FrameType.CANCEL: {\n                                client.unsubscribe()\n                                break\n                            }\n                            case FrameType.REQUEST_N: {\n                                client.request(Number(payload))\n                                break\n                            }\n                        }\n                    })\n                    .subscribe()\n                return Flux.from(sink)\n                    .doOnSubscribe(subscription => {\n                        server.request(Number.MAX_SAFE_INTEGER)\n                        const request = subscription.request\n                        subscription.request = (count: number) => {\n                            request(count)\n                            this.requests.next(new RequestNFrame(streamId, count))\n                        }\n                        const unsubscribe = subscription.unsubscribe\n                        subscription.unsubscribe = () => {\n                            unsubscribe()\n                            if (!completed) this.requests.next(new CancelFrame(streamId))\n                            server.unsubscribe()\n                        }\n                    })\n            })\n    }\n\n    public metadataPush(metadata: Mono<Metadata<any>>): void {\n        metadata.subscribe({\n            onNext: value => this.requests.next(new MetadataPushFrame(value))\n        }).request(1)\n    }\n\n    public disconnect(): void {\n        this.requests.complete()\n    }\n\n    protected websocket() {\n        const websocket = new WebSocket(this.options.url)\n        websocket.binaryType = 'arraybuffer'\n        websocket.addEventListener(\"open\", (_) => {\n            console.debug('websocket open event', websocket)\n            this.requests.addEmitHandler('next', (frame: Frame) => {\n                console.debug('websocket send event', frame, frame.toUint8Array())\n                websocket.send(frame.toUint8Array())\n            })\n            this.requests.addEmitHandler('complete', () => {\n                websocket.close()\n            })\n            this.requests.request(Number.MAX_SAFE_INTEGER)\n        })\n        websocket.addEventListener(\"error\", ev => {\n            console.debug('websocket error event', websocket, ev)\n        })\n        websocket.addEventListener(\"close\", ev => {\n            console.debug('websocket close event', websocket, ev)\n            this.responses.complete()\n        })\n        websocket.addEventListener(\"message\", ev => {\n            this.responses.next(FrameDeserializer.deserialize(\n                new Uint8Array(ev.data),\n                this.options.setup.mimetype.metadata,\n                this.options.setup.mimetype.payload\n            ))\n        })\n    }\n\n    protected setup(metadata?: Mono<M>, payload?: Mono<P>): void {\n        this.normalize(metadata, payload)\n            .subscribe({\n                onNext: ({metadata, payload}) => {\n                    const setup = this.options.setup\n                    const mimetype = setup.mimetype\n                    const version = setup.version\n                    this.requests.next(new SetupFrame(\n                        setup.keepAlive, setup.lifetime,\n                        mimetype.metadata, mimetype.payload,\n                        undefined,\n                        version?.major, version?.minor,\n                        SetupFlag.NONE,\n                        metadata, payload\n                    ))\n                }\n            })\n            .request(1)\n    }\n\n    protected keepAlive() {\n        const request = new KeepaliveFrame(KeepaliveFlag.RESPOND)\n        const respond = new KeepaliveFrame()\n        const schedulers: Array<{ cancel: () => void }> = []\n        Flux.from(this.responses)\n            .filter(frame => frame.type == FrameType.KEEPALIVE)\n            .cast<KeepaliveFrame>()\n            .doOnNext(frame => {\n                if (frame.isRequireRespond()) {\n                    this.requests.next(respond)\n                } else {\n                    schedulers.pop()?.cancel?.()\n                    schedulers.push(Schedulers.delay(this.options.setup.keepAlive).schedule(() => {\n                        schedulers.pop()\n                        schedulers.push(Schedulers.delay(this.options.setup.lifetime).schedule(() => {\n                            schedulers.pop()\n                            this.disconnect()\n                        }))\n                        this.requests.next(request)\n                    }))\n                }\n            })\n            .doFinally(() => schedulers.forEach(scheduler => scheduler.cancel()))\n            .subscribe()\n            .request(Number.MAX_SAFE_INTEGER)\n        this.responses.next(respond)\n    }\n\n    private normalize(metadata?: Mono<M>, payload?: Mono<P>): Mono<{ metadata?: Metadata<M>, payload?: Payload<P> }> {\n        return (metadata || Mono.empty()).switchIfEmpty(Mono.just(0).cast<M>())\n            .zipWith((payload || Mono.empty()).switchIfEmpty(Mono.just(0).cast<P>()))\n            .map(tuple => {\n                const mimetype = this.options.setup.mimetype\n                return {\n                    metadata: tuple[0] ? mimetype.metadata.toMetadata(tuple[0]) : undefined,\n                    payload: tuple[1] ? mimetype.payload.toPayload(tuple[1]) : undefined\n                }\n            })\n    }\n}","import {Flux, Publisher, Sink, Sinks, Subscriber, Subscription} from \"reactor-core-ts\";\n\ntype Handler = (value?: any) => void\n\nexport class Emitter<T> implements Sink<T>, Publisher<T>, Subscription {\n    private readonly sink = Sinks.many().multicast<T>()\n    private readonly handlers = new Map<'next' | 'error' | 'complete', Set<Handler>>()\n    private readonly subscription = Flux.from(this.sink).subscribe({\n        onNext: (value: T) => this.handlers.get('next')?.forEach?.(handler => handler(value)),\n        onError: (error: Error) => this.handlers.get('error')?.forEach?.(handler => handler(error)),\n        onComplete: () => this.handlers.get('complete')?.forEach?.(handler => handler())\n    })\n\n    public addEmitHandler(type: 'next', handler: (value: T) => void): void;\n    public addEmitHandler(type: 'error', handler: (value: Error) => void): void;\n    public addEmitHandler(type: 'complete', handler: () => void): void;\n    public addEmitHandler(type: 'next' | 'error' | 'complete', handler: Handler): void {\n        const handlers = this.handlers.get(type) || new Set<Handler>()\n        handlers.add(handler)\n        this.handlers.set(type, handlers)\n    }\n\n    public removeEmitHandler(type: 'next', handler: (value: T) => void): void;\n    public removeEmitHandler(type: 'error', handler: (value: Error) => void): void;\n    public removeEmitHandler(type: 'complete', handler: () => void): void;\n    public removeEmitHandler(type: 'next' | 'error' | 'complete', handler: Handler): void {\n        this.handlers.get(type)?.delete?.(handler)\n    }\n\n    public next(value: T) {\n        this.sink.next(value)\n    }\n\n    public error(error: Error) {\n        this.sink.error(error)\n    }\n\n    public complete(): void {\n        this.sink.complete()\n    }\n\n    public subscribe(subscriber: Subscriber<T>): Subscription {\n        return this.sink.subscribe(subscriber)\n    }\n\n    public unsubscribe() {\n        this.subscription.unsubscribe()\n    }\n\n    public request(count: number) {\n        this.subscription.request(count)\n    }\n}"],"mappings":"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","names":["Flux","Mono","Schedulers","Sinks","CancelFrame","FireAndForgetFlag","FrameDeserializer","FrameType","KeepaliveFlag","KeepaliveFrame","MetadataPushFrame","PayloadFlag","PayloadFrame","RequestChannelFlag","RequestChannelFrame","RequestFireAndForgetFrame","RequestNFrame","RequestResponseFlag","RequestResponseFrame","RequestStreamFlag","RequestStreamFrame","SetupFlag","SetupFrame","Flux","Sinks","Emitter","value","handler","error","type","handlers","subscriber","count","Connection","options","metadata","payload","Emitter","RequestFireAndForgetFrame","FireAndForgetFlag","streamId","RequestResponseFrame","RequestResponseFlag","Flux","frame","RequestStreamFrame","RequestStreamFlag","sink","Sinks","completed","server","FrameType","subscription","request","count","RequestNFrame","unsubscribe","CancelFrame","payloads","RequestChannelFrame","RequestChannelFlag","client","data","PayloadFrame","PayloadFlag","value","MetadataPushFrame","websocket","_","ev","FrameDeserializer","setup","mimetype","version","SetupFrame","SetupFlag","KeepaliveFrame","KeepaliveFlag","respond","schedulers","Schedulers","scheduler","Mono","tuple"]}