@angular-redux/store

Functions

• dispatch()
• enableFractalReducers()
• select()
• select$()
• WithSubStore()

Classes

• DevToolsExtension

  • enhancer
  • getDevTools
  • isEnabled
• NgRedux

  • configureStore
  • configureSubStore
  • dispatch
  • getState
  • instance
  • provideStore
  • replaceReducer
  • select
  • subscribe
• NgReduxModule

Interfaces

• ObservableStore

  • configureSubStore
  • select

Type Aliases

• Comparator
• FunctionSelector
• PathSelector
• PropertySelector
• Selector
• Transformer

function dispatch

dispatch: () => PropertyDecorator;

• Auto-dispatches the return value of the decorated function.

  Decorate a function creator method with and its return value will automatically be passed to ngRedux.dispatch() for you.

function enableFractalReducers

enableFractalReducers: (
    rootReducer: Reducer<any, AnyAction>
) => Reducer<any, AnyAction>;

• Parameter rootReducer

  Call this on your root reducer to enable SubStore functionality for pre-configured stores (e.g. using NgRedux.provideStore()). NgRedux.configureStore does it for you under the hood.

function select

select: <T>(
    selector?: Selector<any, T>,
    comparator?: Comparator
) => PropertyDecorator;

• Selects an observable from the store, and attaches it to the decorated property.

   import { select } from '@angular-redux/store';
  
   class SomeClass {
     @select(['foo','bar']) foo$: Observable<string>
  }

  Parameter selector

  A selector function, property name string, or property name path (array of strings/array indices) that locates the store data to be selected

  Parameter comparator

  Function used to determine if this selector has changed.

function select$

select$: <T>(
    selector: Selector<any, T>,
    transformer: Transformer<any, T>,
    comparator?: Comparator
) => PropertyDecorator;

• Selects an observable using the given path selector, and runs it through the given transformer function. A transformer function takes the store observable as an input and returns a derived observable from it. That derived observable is run through distinctUntilChanges with the given optional comparator and attached to the store property.

  Think of a Transformer as a FunctionSelector that operates on observables instead of values.

  import { select$ } from 'angular-redux/store';
  
  export const debounceAndTriple = obs$ => obs$
   .debounce(300)
   .map(x => 3 * x);
  
  class Foo {
   @select$(['foo', 'bar'], debounceAndTriple)
   readonly debouncedFooBar$: Observable<number>;
  }

function WithSubStore

WithSubStore: ({
    basePathMethodName,
    localReducer,
}: FractalStoreOptions) => ClassDecorator;

• Modifies the behaviour of any @select, @select$, or @dispatch decorators to operate on a substore defined by the IFractalStoreOptions.

  See: https://github.com/angular-redux/platform/blob/master/packages/store/articles/fractal-store.md for more information about SubStores.

type Comparator

type Comparator = (x: any, y: any) => boolean;

• Custom equality checker that can be used with .select and @select.

  const customCompare: Comparator = (x: any, y: any) => {
   return x.id === y.id
  }
  
  @select(selector, customCompare)

type FunctionSelector

type FunctionSelector<RootState, S> = (s: RootState) => S;

type PathSelector

type PathSelector = (string | number)[];

type PropertySelector

type PropertySelector = string | number | symbol;

type Selector

type Selector<RootState, S> =
    | PropertySelector
    | PathSelector
    | FunctionSelector<RootState, S>;

type Transformer

type Transformer<RootState, V> = (
    store$: Observable<RootState>,
    scope: any
) => Observable<V>;