Let us have a look at how you configure your app:

import { IConfig } from 'overmind'
import { Injectable } from '@angular/core'
import { OvermindService } from 'overmind-angular'
import { state } from './state'
import * as actions from './actions'

export const config = { state, actions }

declare module 'overmind' {
  interface Config extends IConfig<typeof config> {}

  providedIn: 'root'
export class Store extends OvermindService<typeof config> {}

The service is responsible for exposing the configuration of your application. The *track directive is what does the actual tracking. Just put it at the top of your template and whatever state you access will be optimally tracked. You can also select a namespace from your state to expose to the component:

import { Component, ChangeDetectionStrategy } from '@angular/core'
import { Store } from '../overmind'

  selector: 'app-root',
  template: `
<div *track>
  <h1 (click)="actions.changeAdminTitle()">{{ state.adminTitle }}</h1>
  changeDetection: ChangeDetectionStrategy.OnPush
export class AppComponent {
  state = => state.admin)
  actions =
  constructor(private store: Store) {}

You can now access the admin state and actions directly with state and actions.

Polyfill environment

Angular does not inject the environment, so in your polyfill.ts file you have to add the following:

import { environment } from './environments/environment';

(window as any).process = {
  env: {
    NODE_ENV: environment.production ? 'production' : 'development'


The Overmind *track directive knows when your components should update, and so is much more efficient at change detection than Angular's default NgZone. In order to take advantage of the efficiency provided by the *track directive, you must set ngZone to "noop". Note that other 3rd party libraries may not support this. If for any reason you can't set ngZone to "noop", then the *track directive is redundant, and you can safely exclude it from your templates.


When you connect Overmind to your component and expose state you do not have to think about how much state you expose. The exact state that is being accessed in the template is the state that will be tracked. That means you can expose all the state of the application to all your components without worrying about performance.

Passing state as input

When you pass state objects or arrays as input to a child component that state will by default be tracked on the component passing it along, which you can also see in the devtools. By just adding the *tracker directive to the child template, the tracking will be handed over:

import { Component, Input, ChangeDetectionStrategy } from '@angular/core'
import { Todo } from '../overmind/state'

  selector: 'todos-todo',
  template: `
<li *track>{{ todo.title }}</li>
  changeDetection: ChangeDetectionStrategy.OnPush,
export class TodoComponent {
  @Input() todo: Todo

What is important to understand here is that Overmind is not immutable. That means if you would change any property on any todo, only the component actually looking at the todo will render. The list is untouched.


To run effects in components based on changes to state you use the reaction function in the lifecycle hooks of Angular.

import { Component } from '@angular/core'
import { Store } from '../overmind'

  selector: 'app-root',
  templateUrl: './app.component.html'
export class AppComponent {
  disposeReaction: () => void
  constructor (private store: Store) {}
  ngOnInit() {
    this.disposeReaction =
      ({ currentPage }) => currentPage,
      () => document.querySelector('#app').scrollTop = 0
  ngOnDestroy() {

Last updated