ngrx-loading-state
Version:
NgRx Loading State consistently manages loading actions such as API fetches.
87 lines • 10.6 kB
JavaScript
import { createSelector } from '@ngrx/store';
import { LoadingActions } from './loading-state-actions';
import { actionFactory } from './loading-state-functions';
export function load() {
return new Load();
}
export function success() {
return new Success();
}
export function failure() {
return new Failure();
}
/**
* Creates a set of load, success, failure actions. Selectors and reducers are always bundled into
* the same structure.
*
* @param type The "type" of the action.
* @param _load See usage example
* @param _success See usage example
* @param _failure See usage example
* @returns An instance of LoadingActions class that bundles together actions, selectors and reducers.
* @example
* export const fetchItem = createLoadingActions(
* 'Fetch Item',
* load<{ itemId: number }>(), // Action type is: 'Fetch Item'
* success<{ item: object }>(), // Action type is: 'Fetch Item Success'
* failure<{}>() // Action type is: 'Fetch Item Failure'
* );
*/
export function createLoadingActions(type, _load, _success, _failure) {
return new LoadingActions({
load: actionFactory(`${type}`),
success: actionFactory(`${type} Success`),
failure: actionFactory(`${type} Failure`)
});
}
/**
*
* @param featureSelector Selector that selects the current feature slice of the store.
* @returns Selector that selects the loadingStates field from the store
* @example
* // Using ngrx's createFeatureSelector to select the feature slice from global store.
* const selectState = createFeatureSelector<SimpleState>(SIMPLE_FEATURE_KEY);
* const selectLoadingStates = createLoadingStatesSelector(selectState);
*
* You can then use selectLoadingStates to compose other selectors. eg.
*
* export const fetchItem = createLoadingActions(
* 'Fetch Item',
* load<{ itemId: number }>(),
* success<{ item: object }>(),
* failure<{}>()
* );
*
* export const fetchItemSelectors = fetchItem.createSelectors(selectLoadingStates);
*
*/
export function createLoadingStatesSelector(featureSelector) {
return createSelector(featureSelector, (state) => {
return state.loadingStates;
});
}
// ------------------------------------------------------------------------
// Internal
// ------------------------------------------------------------------------
// These classes are basically serving the same purpose as props<T> in createAction() where it
// just holds the type and allows you to name the class to make it easier to read. The alternative
// is to explicitly specify the type when calling createLoadingActions<...>(). But the template
// types are positional only, so not easy to read.
class Load {
constructor() {
// These variables with constant string typing prevents Load and Success instances from being
// assignable to each other.
this.type = 'LOAD';
}
}
class Success {
constructor() {
this.type = 'SUCCESS';
}
}
class Failure {
constructor() {
this.type = 'FAILURE';
}
}
//# sourceMappingURL=data:application/json;base64,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