protected _activate()

in src/component/cover/CoverComponent.ts [42:156]
103 lines of code
8 McCabe index (conditional complexity)

    protected _activate(): void {
        const originalSrc$ = this.configuration$.pipe(
            first(
                (c: CoverConfiguration): boolean => {
                    return !!c.id;
                }),
            filter(
                (c: CoverConfiguration): boolean => {
                    return !c.src;
                }),
            switchMap(
                (c: CoverConfiguration): Observable<string> => {
                    return this._getImageSrc$(c.id).pipe(
                        catchError(
                            (error: Error): Observable<string> => {
                                console.error(error);

                                return observableEmpty();
                            }));
                }),
            publishReplay(1),
            refCount());

        const subs = this._subscriptions;

        subs.push(originalSrc$.pipe(
            map(
                (src: string): CoverConfiguration => {
                    return { src: src };
                }))
            .subscribe(
                (c: CoverConfiguration): void => {
                    this._configurationSubject$.next(c);
                }));

        subs.push(observableCombineLatest(
            this.configuration$,
            originalSrc$).pipe(
                filter(
                    ([c, src]: [CoverConfiguration, string]): boolean => {
                        return !!c.src && c.src !== src;
                    }),
                first())
            .subscribe(
                ([, src]: [CoverConfiguration, string]): void => {
                    window.URL.revokeObjectURL(src);
                }));

        subs.push(this._configuration$.pipe(
            distinctUntilChanged(
                undefined,
                (configuration: CoverConfiguration): CoverState => {
                    return configuration.state;
                }),
            switchMap(
                (configuration: CoverConfiguration): Observable<[CoverState, MImage]> => {
                    return observableCombineLatest(
                        observableOf(configuration.state),
                        this._navigator.stateService.currentImage$);
                }),
            switchMap(
                ([state, image]: [CoverState, MImage]): Observable<[string, string]> => {
                    const keySrc$: Observable<[string, string]> = observableCombineLatest(
                        observableOf(image.id),
                        image.image$.pipe(
                            filter(
                                (imageElement: HTMLImageElement): boolean => {
                                    return !!imageElement;
                                }),
                            map(
                                (imageElement: HTMLImageElement): string => {
                                    return imageElement.src;
                                })));

                    return state === CoverState.Visible ? keySrc$.pipe(first()) : keySrc$;
                }),
            distinctUntilChanged(
                ([k1, s1]: [string, string], [k2, s2]: [string, string]): boolean => {
                    return k1 === k2 && s1 === s2;
                }),
            map(
                ([key, src]: [string, string]): CoverConfiguration => {
                    return { id: key, src: src };
                }))
            .subscribe(this._configurationSubject$));

        subs.push(observableCombineLatest(
            this._configuration$,
            this._container.configurationService.exploreUrl$,
            this._container.renderService.size$).pipe(
                map(
                    ([configuration, exploreUrl, size]:
                        [CoverConfiguration, string, ViewportSize]): VirtualNodeHash => {
                        if (!configuration.src) {
                            return { name: this._name, vNode: vd.h("div", []) };
                        }

                        const compactClass: string = size.width <= 640 || size.height <= 480 ? ".mapillary-cover-compact" : "";

                        if (configuration.state === CoverState.Hidden) {
                            const doneContainer: vd.VNode = vd.h(
                                "div.mapillary-cover-container.mapillary-cover-done" + compactClass,
                                [this._getCoverBackgroundVNode(configuration)]);

                            return { name: this._name, vNode: doneContainer };
                        }

                        const container: vd.VNode = vd.h(
                            "div.mapillary-cover-container" + compactClass,
                            [this._getCoverButtonVNode(configuration, exploreUrl)]);

                        return { name: this._name, vNode: container };
                    }))
            .subscribe(this._container.domRenderer.render$));
    }