@angular/common#isPlatformServer TypeScript Examples

constructor(
    private router: Router,
    protected appState$: Store<store.AppState>,
    public snackBar: MatSnackBar,
    @Inject(PLATFORM_ID) private platformId: Object
  ) {
    this.productTotal = 0;
    this.completeOrder();
    if (isPlatformBrowser(this.platformId)) {
      const cartParams: any = {};
      cartParams.products = sessionStorage.getItem('selectedProducts')
        ? JSON.parse(sessionStorage.getItem('selectedProducts'))
        : [];
      cartParams.productTotal = sessionStorage.getItem('selectedProductsCount')
        ? +JSON.parse(sessionStorage.getItem('selectedProductsCount'))
        : 0;
      cartParams.totalPrice = sessionStorage.getItem('productTotal')
        ? +JSON.parse(sessionStorage.getItem('productTotal'))
        : 0;
      this.HandleCart(cartParams);
    }
    if (isPlatformServer(this.platformId)) {
    }
  }

/**
     * On component view checked
     */
    ngAfterViewChecked() {
        if (isPlatformServer(this.platformId)) {
            return;
        }
        if (this._addedSlides.length > 0 || this._removedSlides.length > 0) {
            const nextSlidesLength = this.slides.length - this._removedSlides.length + this._addedSlides.length;
            if (!this.initialized) {
                if (nextSlidesLength > 0) {
                    this.initSlick();
                }
                // if nextSlidesLength is zere, do nothing
            } else if (nextSlidesLength === 0) {
                // unslick case
                this.unslick();
            } else {
                this._addedSlides.forEach((slickItem) => {
                    this.slides.push(slickItem);

                    this.slick.addSlide(slickItem.el.nativeElement);
                });
                this._addedSlides = [];

                this._removedSlides.forEach((slickItem) => {
                    const idx = this.slides.indexOf(slickItem);
                    this.slides = this.slides.filter((s) => s !== slickItem);

                    this.slick.removeSlide(idx);
                });
                this._removedSlides = [];
            }
        }
    }

init() {
    if (isPlatformServer(this.platformId)) {
      return;
    }

    this.reset();

    let elementToListenScrollEvent;
    let scrollingElement: HTMLElement;
    if (!this.scrollingElementSelector) {
      elementToListenScrollEvent = window;
      scrollingElement = this.getDefaultScrollingElement();
    } else {
      scrollingElement = document.querySelector(this.scrollingElementSelector) as HTMLElement;
      if (!scrollingElement) {
        console.warn(`NgxHideOnScroll: @Input() scrollingElementSelector\nElement with selector: "${this.scrollingElementSelector}" not found.`);
        return;
      }
      elementToListenScrollEvent = scrollingElement;
    }

    /* elementToListenScrollEvent.addEventListener("scroll", e => {
      console.log("MANUAL ON SCROLL", e)
    }) */

    /*  elementToListenScrollEvent.addEventListener("ionScroll", e => {
       console.log("MANUAL ON ION-SCROLL", e)
     })
  */
    const scroll$ = fromEvent<ScrollCustomEvent>(elementToListenScrollEvent, 'ionScroll').pipe(
      takeUntil(this.unsubscribeNotifier),
      throttleTime(50), // only emit every 50 ms
      map(event => event.detail.scrollTop), // get vertical scroll position
      pairwise(),  // look at this and the last emitted element
      // compare this and the last element to figure out scrolling direction
      map(([y1, y2]): ScrollDirection => (y2 < y1 ? ScrollDirection.Up : ScrollDirection.Down)),
      distinctUntilChanged(), // only emit when scrolling direction changed
      share(), // share a single subscription to the underlying sequence in case of multiple subscribers
    );

    const scrollUp$ = scroll$.pipe(
      filter(direction => direction === ScrollDirection.Up)
    );

    const scrollDown$ = scroll$.pipe(
      filter(direction => direction === ScrollDirection.Down)
    );

    let scrollUpAction: () => void;
    let scrollDownAction: () => void;
    if (this.hideOnScroll === 'Up') {
      scrollUpAction = () => this.hideElement(scrollingElement);
      scrollDownAction = () => this.showElement(scrollingElement);
    } else {
      scrollUpAction = () => this.showElement(scrollingElement);
      scrollDownAction = () => this.hideElement(scrollingElement);
    }

    scrollUp$.subscribe(() => {
      scrollUpAction()
    });
    scrollDown$.subscribe(() => {
      scrollDownAction()
    });
  }

ngAfterViewInit() {
    if (isPlatformServer(this.platform)) return;
    this.setTooltips();
  }

ngAfterViewInit() {
    if (isPlatformServer(this.platform)) return;
    this.setSingleton();
  }

ngOnInit() {
    if (isPlatformServer(this.platform)) return;
    this.ngxViewService.viewContainerRef = this.viewContainerRef;
    this.initTippy();
  }

intercept(req: HttpRequest<any>, next: HttpHandler) {
    // this.spinner.show();
    if (isPlatformBrowser(this.platformId)) {
      this.userTokenDetail = localStorage.getItem('userToken');
    }
    if (isPlatformServer(this.platformId)) {
    }
    if (this.userTokenDetail) {
      req = req.clone({
        setHeaders: {
          Authorization: 'Bearer ' + this.userTokenDetail
        }
      });
    }

    return next.handle(req).pipe(
      map((user: any) => {
        if (user instanceof HttpResponse) {
          const response = user.body;
          if (
            response.message &&
            response.message !== '' &&
            req.method !== 'GET' &&
            response.message !== 'Redirect to this url.'
          ) {
            this.showSuccess(user.body.message);
          }
        }
        return user;
      }),
      catchError(response => {
        this.spinner.hide();
        if (response.status === 200 || response.status === 201) {
          return response;
        }
        switch (response.status) {
          case 400:
            this.handleBadRequest(response);
            break;
          case 401:
            this.handleUnAuthorized();
            break;
          case 403:
            this.handleUnAuthorized();
            break;
          case 500:
            this.handleServerError();
            break;
          default:
            break;
        }
        return throwError(response);
      })
    );
  }

getResize(): Observable<Event> {
        return isPlatformServer(this.platformId) ? EMPTY : fromEvent(window, 'resize').pipe(auditTime(150));
    }