@ngrx/store#Store TypeScript Examples

constructor(private store$: Store<AppState>) {
    this.subs.push(
      this.appSettings$.pipe(
        first(),
        map(({theme}) => {
          this.setTheme(theme);
        })
      ).subscribe()
    );
  }

constructor(private store: Store<fromBooks.State>) {
    this.searchQuery$ = store.pipe(
      select(fromBooks.selectSearchQuery),
      take(1)
    );
    this.books$ = store.pipe(select(fromBooks.selectSearchResults));
    this.loading$ = store.pipe(select(fromBooks.selectSearchLoading));
    this.error$ = store.pipe(select(fromBooks.selectSearchError));
  }

createParentInjector(injector: Injector) {
    return Injector.create({
      providers: [
        {
          provide: Router,
          useValue: null,
        },
        {
          provide: Store,
          useValue: null,
        },
        {
          provide: EffectsRunner,
          useValue: null,
        },
        {
          provide: PlatformLocation,
          useClass: AppPlatformLocation,
          deps: [],
        },
      ],
      parent: injector,
    });
  }

constructor(
    private store: Store<{ app: AppState }>,
    private cookies: CookiesService,
    public dialog: MatDialog,
    private analytics: AnalyticsService
  ) {
    this.filteredBonusCards = this.store.select(({ app }) => app.activeBonusCards)
    this.bonusCards = this.store.select(({ app }) => app.bonusCards)
    this.query = {
      ...this.query,
      expansion: {
        originalcore: cookies.getCookie('expansion.core') !== '0',
        swiftstart: cookies.getCookie('expansion.swiftstart') !== '0',
        european: cookies.getCookie('expansion.european') !== '0',
        oceania: cookies.getCookie('expansion.oceania') !== '0',
      }
    }

    this.selectedExpansions = Object.entries(this.query.expansion).reduce((acc, entry) => entry[1] ? [...acc, entry[0]] : acc, [])
    store.dispatch(search(this.query))
  }

constructor(private store: Store) {
    this.stats$ = this.store.select(fromIssue.selectStats);
    this.navigationLoading$ = this.store
      .select(fromNavigation.selectLoading)
      .pipe(
        // delay spinner deactivation, so we can see the spinner for a bit
        delayWhen((loading) => interval(loading ? 0 : 500))
      );
  }

constructor(private store: Store<AppState>, public rest: RestService, public dialog: MatDialog, private eventEmitterService: EventEmitterService) {
    const project = this.store.select('project')

    project.pipe(takeUntil(this.unSubscribe$)).subscribe((v) => {
      this.services = v.services

      setTimeout(() => {
        this.currentService = this.services.find((s: Service) => s.uuid === this.node.uuid)
      })
    })
  }

public constructor(
    private sidebarService: NbSidebarService,
    private menuService: NbMenuService,
    private themeService: NbThemeService,
    private layoutService: LayoutService,
    private breakpointService: NbMediaBreakpointsService,
    private rippleService: RippleService,
    private store: Store<fromRoot.State>,
  ) {
    this.materialTheme$ = this.themeService.onThemeChange().pipe(
      map(theme => {
        const themeName: string = theme?.name || '';
        return themeName.startsWith('material');
      }),
    );
  }

constructor(
    private actions$: Actions,
    private store: Store<State>,
    private router: Router,
    private overlayContainer: OverlayContainer,
    private localStorageService: LocalStorageService,
    private titleService: TitleService,
    private animationsService: AnimationsService,
    private translateService: TranslateService,
    private ngZone: NgZone
  ) {}

constructor(private store$: Store<any>) {
    gsap.registerPlugin(Draggable);
    this.loadApplications();
    this.loadFiles();
  }

constructor(
    private bucketService: BucketService,
    private store: Store<AppState>
  ) {}

constructor(private store: Store<IAuthStoreFeatureKey>) {
  }

constructor(
    private httpClient: HttpClient,
    private localStorageService: LocalStorageService,
    private store: Store<AppState>
  ) {}

constructor(private store: Store<fromAuth.State>) {}

constructor(private store: Store<RootState>) { }

constructor(private store: Store<DatafeederState>) {}

ngOnDestroy() {
    if (this.currentNgModuleRef) {
      this.currentNgModuleRef.injector.get(Store, null)?.complete();
      this.currentNgModuleRef.destroy();
      this.currentNgModuleRef = undefined;
    }
  }

constructor(
    @Inject(MAT_DIALOG_DATA) public data: { card: BirdCard },
    private store: Store<{ app: AppState }>,
    private sanitizer: DomSanitizer
  ) { }

constructor(private store: Store) {
    this.notificationPriority$ = this.store.select(
      fromNotification.selectPriority
    );
  }

constructor(public dialogRef: MatDialogRef<BuildDialogComponent>, private formBuilder: FormBuilder, @Inject(MAT_DIALOG_DATA) public data: Service, private store: Store, private eventEmitterService: EventEmitterService,) { }

constructor(private _loadingService: TdLoadingService, private formBuilder: FormBuilder, private store: Store<fromRoot.State>) {}