rxjs#forkJoin TypeScript Examples

canActivate(
    route: ActivatedRouteSnapshot,
    state: RouterStateSnapshot): Observable<boolean | UrlTree> | Promise<boolean | UrlTree> | boolean | UrlTree {
    return selectPersistStateInit()
      .pipe(switchMap(() => {
        return forkJoin([
          this.walletsQuery.selectAll().pipe(take(1)),
          this.walletsAccountsQuery.selectAll().pipe(take(1))
        ])
          .pipe(map(values => {
            const canAccess = values.every(value => value.length > 0);

            if (!canAccess) {
              this.router.navigate(['/connect/no-wallet'], {
                queryParams: route.queryParams,
              });
              return false;
            } else {
              return true;
            }
          }));
      }));
  }

private checkAllRpcProviders(timeout?: number): void {
    const checkNode$ = (web3Public: EthLikeWeb3Public | SolanaWeb3Public) =>
      web3Public.healthCheck(timeout).pipe(
        tap(isNodeWorks => {
          if (isNodeWorks) {
            return;
          }

          if (web3Public instanceof SolanaWeb3Public) {
            this.setSolanaWeb3('additional');
            console.debug(`Broken Solana node has been replaced with a spare.`);
            return;
          }

          const blockchainName = web3Public.blockchain.name;
          const connector = this.connectionLinks.find(
            item => item.blockchainName === blockchainName
          );
          if (connector?.additionalRpcLink) {
            this[blockchainName].setProvider(connector.additionalRpcLink);
            console.debug(
              `Broken ${web3Public.blockchain.name} node has been replaced with a spare.`
            );
          }
        })
      );

    forkJoin([
      ...ETH_LIKE_BLOCKCHAIN_NAMES.map(ethLikeBlockchainName =>
        checkNode$(this[ethLikeBlockchainName])
      ),
      checkNode$(this[BLOCKCHAIN_NAME.SOLANA])
    ]).subscribe(() => this._nodesChecked$.next(true));
  }

getLatestBalance() {
    const pool$ = this.getPoolCurrentBalance()
      .pipe(
        first(),
        tap(balance => this.poolBalance$.next(balance)),
      );
    const user$ = this.getUserCurrentBalance()
      .pipe(
        first(),
        tap(balance => this.userBalance$.next(balance)),
      );
    return forkJoin([pool$, user$]);
  }

getAll() {
    const keys = Object.keys(this.assetsToLoad);
    const calls = [];
    keys.map(async (assetKey) => {
      calls.push(
        this.loadAsset(assetKey)
      );
    });
    return forkJoin(calls).pipe(
      map(results => {
        keys.map((key, index) => this.assetsToLoad[key] = {
          ...this.assetsToLoad[key],
          loaded: true,
          resource: results[index]
        });
        return this.assetsToLoad;
      })
    );
  }

public getFeaturedAddons(installation: WowInstallation): Observable<AddonSearchResult[]> {
    return forkJoin(
      this._addonProviderService.getEnabledAddonProviders().map(async (p) => {
        try {
          return await p.getFeaturedAddons(installation);
        } catch (e) {
          console.error(`Failed to get featured addons: ${p.name}`, e);
          this._searchErrorSrc.next(new GenericProviderError(e as Error, p.name));
          return [];
        }
      })
    ).pipe(
      map((results) => {
        return _.orderBy(results.flat(1), ["downloadCount"]).reverse();
      })
    );
  }

constructor(private phoneService: PhoneData) {
    forkJoin(
      this.phoneService.getContacts(),
      this.phoneService.getRecentUsers(),
    )
      .pipe(takeWhile(() => this.alive))
      .subscribe(([contacts, recent]: [Contact[], RecentUser[]]) => {
        this.contacts = contacts;
        this.recent = recent;
      });
  }

initializeState() {
    console.debug('initializeState()')

    return forkJoin([
      this.getServerVersion(),
      // this.getBuildConfig(),
      this.getPublicKeyAndOracleName(),
      this.getStakingAddressAndBalance(),
      // this.getAllAnnouncements(), // pulling in oracle component
    ]).subscribe(_ => {
      console.debug(' initializedState() initialized')
      this.stateLoaded.next()
    })
  }

private initGeos() {
    let loadCountries$: Observable<Country[]> = this.geoService.fetchAllCountries();
    let loadStates$: Observable<State[]> = this.geoService.fetchAllStates();

    forkJoin([
      loadCountries$,
      loadStates$
    ]).subscribe(([allCountries, allStates]) => {
      this.handleCountryResponse(allCountries);
      this.handleStateResponse(allStates);
      this.showForm();
    },
      (err: Error) => this.handleGeoError(err)
    );
  }

/**
     * Parses value for references
     * @param value the value to match citations within
     * @param restApiConnector to connect to the REST API
     * @param validateReferencesAndCitations 
     */
    public parseCitations(value: string, restApiConnector: RestApiConnectorService): Observable<CitationParseResult> {
        let reReference = /\(Citation: (.*?)\)/gmu;
        let citations = value.match(reReference);
        let result = new CitationParseResult({
            brokenCitations: this.validateBrokenCitations(value, [/\(Citation:([^ ].*?)\)/gmu, /\(citation:(.*?)\)/gmu])
        })

        if (citations) {
            // build lookup api map
            let api_map = {};
            for (let i = 0; i < citations.length; i++) {
                // Split to get source name from citation
                let sourceName = citations[i].split("(Citation: ")[1].slice(0, -1);
                api_map[sourceName] = this.checkAndAddReference(sourceName, restApiConnector);
            }
            // check/add each citation
            return forkJoin(api_map).pipe(
                map((api_results) => {
                    let citation_results = api_results as any;
                    for (let key of Object.keys(citation_results)) {
                        // was the result able to be found/added?
                        if (citation_results[key]) result.usedCitations.add(key)
                        else result.missingCitations.add(key)
                    }
                    return result;
                })
            )
        } else {
            return of(result);
        }
    }

getExampleFiles(files : Array<String>) {
    let result = [];

    files.forEach(file => {
      result.push(this.getContentTab(`${this.rootExamplesPath}${file}.properties`))
    });

   return forkJoin(result);
  }

signOut() {
    try {
      forkJoin({
        device: this.deviceService.getDeviceInfo(),
        eou: from(this.authService.getEou()),
      })
        .pipe(
          switchMap(({ device, eou }) =>
            this.authService.logout({
              device_id: device.uuid,
              user_id: eou.us.id,
            })
          ),
          finalize(() => {
            this.secureStorageService.clearAll();
            this.storageService.clearAll();
            globalCacheBusterNotifier.next();
            this.userEventService.logout();
          })
        )
        .subscribe(noop);
    } catch (e) {
      this.secureStorageService.clearAll();
      this.storageService.clearAll();
      globalCacheBusterNotifier.next();
    }
  }

handleFeatureInfo(): void {
    const { map } = this.manager
    map.on('click', (event) => {
      const gfiFeaturesObservables = this.mapUtils.getGFIFeaturesObservablesFromClick(
        map,
        event
      )
      const vectorFeatures$ = of(
        this.mapUtils.getVectorFeaturesFromClick(map, event)
      )

      const featuresObservablesArray: Observable<Feature<Geometry>[]>[] = [
        ...gfiFeaturesObservables,
        vectorFeatures$,
      ]

      forkJoin(...featuresObservablesArray).subscribe((featuresArrays) => {
        const allFeatures = featuresArrays.reduce(
          (outputFeatures, features) => [...outputFeatures, ...features],
          []
        )
        this.features$.emit(allFeatures)
      })
    })
  }

private getBackendObjects() {
    console.log(
      $localize`Fetching info for InferenceService ${this.namespace}/${this.serverName}`,
    );

    this.backend
      .getInferenceService(this.namespace, this.serverName)
      .subscribe(svc => {
        this.updateInferenceService(svc);

        const components = ['predictor', 'transformer', 'explainer'];
        const obs: Observable<[string, string, ComponentOwnedObjects]>[] = [];

        ['predictor', 'transformer', 'explainer'].forEach(component => {
          obs.push(this.getOwnedObjects(svc, component));
        });

        forkJoin(...obs).subscribe(objects => {
          const ownedObjects = {};
          for (const obj of objects) {
            const component = obj[0];

            ownedObjects[component] = obj[1];
          }

          this.ownedObjects = ownedObjects;
          this.serverInfoLoaded = true;
        });
      });
  }

getAllInfoFromArtist() {
    const requests = [];

    requests.push(
      this.getArtist(),
      this.getArtistTopTracks(),
      this.getArtistRelated(),
      this.getArtistAlbums(),
    );

    forkJoin(requests)
      .subscribe((items: any[]) => {
        this.artist = items[0];
        this.topTracks = items[1];
        this.related = items[2];
        this.albums = items[3];

        window.scrollTo(0, 0);
      });
  }