ngrx-loading-state
Version:
NgRx Loading State consistently manages loading actions such as API fetches.
107 lines • 13.4 kB
JavaScript
// 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
import { createSelector } from '@ngrx/store';
import { actionFactory } from '../loading-state/loading-state-functions';
import { IdLoadingActions } from './id-loading-state-actions';
export function idLoad() {
return new IdLoad();
}
export function idSuccess() {
return new IdSuccess();
}
export function idFailure() {
return new IdFailure();
}
/**
* Creates a set of IdLoadAction, IdSuccessAction, and IdFailureAction. Selectors and reducers are always bundled into
* the same structure.
*
* The difference between IdLoadAction and LoadAction is that IdLoadAction is parameterized by an id field. So you can
* display loading states for multiple items that are all loading in parallel. Typical use case is you have a list of items,
* and you can issue load actions for each one, parameterized by an id of your own choosing, and observe the loading state
* of each item, again parameterized by the id.
*
* @param type The "type" of the action.
* @param _idLoad See usage example
* @param _idSuccess See usage example
* @param _idFailure See usage example
* @returns An instance of LoadingActions class that bundles together actions, selectors and reducers.
* @example
* export const fetchItem = createIdLoadingActions(
* 'Fetch Item',
* // An id field is already included in each of LoadAction, SuccessAction, FailureAction
* load<{}>(),
* success<{ item: object }>(),
* failure<{}>()
* );
*
* // Dispatch load action
* const id = "123";
* this.store.dispatch(fetchItem.idLoad({ id }));
*
* // Using ngrx's createFeatureSelector to select the feature slice from global store.
* const selectState = createFeatureSelector<SimpleState>(SIMPLE_FEATURE_KEY);
* const selectLoadingStates = createLoadingStatesSelector(selectState);
*
* const fetchItemSelectors = fetchItem.createIdSelectors(selectLoadingStates);
*
* // Observe the loading state.
* this.store.select(fetchItemSelectors.state(id));
*
*/
export function createIdLoadingActions(actionTypePrefix, _idLoad, _idSuccess, _idFailure) {
return new IdLoadingActions({
idLoad: actionFactory(`${actionTypePrefix}`),
idSuccess: actionFactory(`${actionTypePrefix} Success`),
idFailure: actionFactory(`${actionTypePrefix} 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 = createIdLoadingActions(
* 'Fetch Item',
* load<{}>(),
* success<{ item: object }>(),
* failure<{}>()
* );
*
* export const fetchItemSelectors = fetchItem.createSelectors(selectLoadingStates);
*
*/
export function createIdLoadingStatesSelector(featureSelector) {
return createSelector(featureSelector, (state) => {
return state.idLoadingStates;
});
}
// ------------------------------------------------------------------------
// Internal
// ------------------------------------------------------------------------
// types are positional only, so not easy to read.
class IdLoad {
constructor() {
// These variables with constant string typing prevents Load and Success instances from being
// assignable to each other.
this.type = 'ID_LOAD';
}
}
class IdSuccess {
constructor() {
this.type = 'ID_SUCCESS';
}
}
class IdFailure {
constructor() {
this.type = 'ID_FAILURE';
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"id-loading-state-creators.js","sourceRoot":"","sources":["../../../../../projects/ngrx-loading-state/src/lib/id-loading-state/id-loading-state-creators.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,kGAAkG;AAClG,gGAAgG;AAEhG,OAAO,EAAE,cAAc,EAAwC,MAAM,aAAa,CAAC;AACnF,OAAO,EAAE,aAAa,EAAE,MAAM,0CAA0C,CAAC;AAEzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAS9D,MAAM,UAAU,MAAM;IAGpB,OAAO,IAAI,MAAM,EAAmB,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,SAAS;IAGvB,OAAO,IAAI,SAAS,EAAsB,CAAC;AAC7C,CAAC;AAED,MAAM,UAAU,SAAS;IAGvB,OAAO,IAAI,SAAS,EAAsB,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,UAAU,sBAAsB,CAKpC,gBAAwB,EACxB,OAAgC,EAChC,UAAyC,EACzC,UAAyC;IAEzC,OAAO,IAAI,gBAAgB,CAAC;QAC1B,MAAM,EAAE,aAAa,CAAiC,GAAG,gBAAgB,EAAE,CAAC;QAC5E,SAAS,EAAE,aAAa,CAAuC,GAAG,gBAAgB,UAAU,CAAC;QAC7F,SAAS,EAAE,aAAa,CAAuC,GAAG,gBAAgB,UAAU,CAAC;KAC9F,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,eAA2E;IAE3E,OAAO,cAAc,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,EAAE;QAC/C,OAAO,KAAK,CAAC,eAAe,CAAC;IAC/B,CAAC,CAAC,CAAC;AACL,CAAC;AAED,2EAA2E;AAC3E,WAAW;AACX,2EAA2E;AAE3E,kDAAkD;AAClD,MAAM,MAAM;IAAZ;QACE,6FAA6F;QAC7F,4BAA4B;QAC5B,SAAI,GAAc,SAAS,CAAC;IAC9B,CAAC;CAAA;AACD,MAAM,SAAS;IAAf;QACE,SAAI,GAAiB,YAAY,CAAC;IACpC,CAAC;CAAA;AACD,MAAM,SAAS;IAAf;QACE,SAAI,GAAiB,YAAY,CAAC;IACpC,CAAC;CAAA","sourcesContent":["// These classes are basically serving the same purpose as props<T> in createAction() where it\n// just holds the type and allows you to name the class to make it easier to read. The alternative\n// is to  explicitly specify the type when calling createLoadingActions<...>(). But the template\n\nimport { createSelector, DefaultProjectorFn, MemoizedSelector } from '@ngrx/store';\nimport { actionFactory } from '../loading-state/loading-state-functions';\nimport { NoIntersection } from '../utils';\nimport { IdLoadingActions } from './id-loading-state-actions';\nimport {\n  IdFailureAction,\n  IdLoadAction,\n  IdLoadingStates,\n  IdSuccessAction,\n  WithIdLoadingStatesOnly\n} from './id-loading-state-types';\n\nexport function idLoad<\n  LoadPayloadType extends NotIdLoadingAction<LoadPayloadType>\n>(): IdLoad<LoadPayloadType> {\n  return new IdLoad<LoadPayloadType>();\n}\n\nexport function idSuccess<\n  SuccessPayloadType extends NotIdSuccessAction<SuccessPayloadType>\n>(): IdSuccess<SuccessPayloadType> {\n  return new IdSuccess<SuccessPayloadType>();\n}\n\nexport function idFailure<\n  FailurePayloadType extends NotIdFailureAction<FailurePayloadType>\n>(): IdFailure<FailurePayloadType> {\n  return new IdFailure<FailurePayloadType>();\n}\n\n/**\n * Creates a set of IdLoadAction, IdSuccessAction, and IdFailureAction. Selectors and reducers are always bundled into\n * the same structure.\n *\n * The difference between IdLoadAction and LoadAction is that IdLoadAction is parameterized by an id field. So you can\n * display loading states for multiple items that are all loading in parallel. Typical use case is you have a list of items,\n * and you can issue load actions for each one, parameterized by an id of your own choosing, and observe the loading state\n * of each item, again parameterized by the id.\n *\n * @param type The \"type\" of the action.\n * @param _idLoad See usage example\n * @param _idSuccess See usage example\n * @param _idFailure See usage example\n * @returns An instance of LoadingActions class that bundles together actions, selectors and reducers.\n * @example\n *  export const fetchItem = createIdLoadingActions(\n *    'Fetch Item',\n *    // An id field is already included in each of LoadAction, SuccessAction, FailureAction\n *    load<{}>(),\n *    success<{ item: object }>(),\n *    failure<{}>()\n *  );\n *\n *  // Dispatch load action\n *  const id = \"123\";\n *  this.store.dispatch(fetchItem.idLoad({ id }));\n *\n *  // Using ngrx's createFeatureSelector to select the feature slice from global store.\n *  const selectState = createFeatureSelector<SimpleState>(SIMPLE_FEATURE_KEY);\n *  const selectLoadingStates = createLoadingStatesSelector(selectState);\n *\n *  const fetchItemSelectors = fetchItem.createIdSelectors(selectLoadingStates);\n *\n *  // Observe the loading state.\n *  this.store.select(fetchItemSelectors.state(id));\n *\n */\nexport function createIdLoadingActions<\n  LoadPayloadType extends object,\n  SuccessPayloadType extends object,\n  FailurePayloadType extends object\n>(\n  actionTypePrefix: string,\n  _idLoad: IdLoad<LoadPayloadType>,\n  _idSuccess: IdSuccess<SuccessPayloadType>,\n  _idFailure: IdFailure<FailurePayloadType>\n): IdLoadingActions<LoadPayloadType, SuccessPayloadType, FailurePayloadType> {\n  return new IdLoadingActions({\n    idLoad: actionFactory<IdLoadAction & LoadPayloadType>(`${actionTypePrefix}`),\n    idSuccess: actionFactory<IdSuccessAction & SuccessPayloadType>(`${actionTypePrefix} Success`),\n    idFailure: actionFactory<IdFailureAction & FailurePayloadType>(`${actionTypePrefix} Failure`)\n  });\n}\n\n/**\n *\n * @param featureSelector Selector that selects the current feature slice of the store.\n * @returns Selector that selects the loadingStates field from the store\n * @example\n *  // Using ngrx's createFeatureSelector to select the feature slice from global store.\n *  const selectState = createFeatureSelector<SimpleState>(SIMPLE_FEATURE_KEY);\n *  const selectLoadingStates = createLoadingStatesSelector(selectState);\n *\n *  You can then use selectLoadingStates to compose other selectors. eg.\n *\n *  export const fetchItem = createIdLoadingActions(\n *    'Fetch Item',\n *    load<{}>(),\n *    success<{ item: object }>(),\n *    failure<{}>()\n *  );\n *\n *  export const fetchItemSelectors = fetchItem.createSelectors(selectLoadingStates);\n *\n */\nexport function createIdLoadingStatesSelector<State extends WithIdLoadingStatesOnly>(\n  featureSelector: MemoizedSelector<object, State, DefaultProjectorFn<State>>\n): MemoizedSelector<object, IdLoadingStates, DefaultProjectorFn<IdLoadingStates>> {\n  return createSelector(featureSelector, (state) => {\n    return state.idLoadingStates;\n  });\n}\n\n// ------------------------------------------------------------------------\n// Internal\n// ------------------------------------------------------------------------\n\n// types are positional only, so not easy to read.\nclass IdLoad<_LoadPayloadType> {\n  // These variables with constant string typing prevents Load and Success instances from being\n  // assignable to each other.\n  type: 'ID_LOAD' = 'ID_LOAD';\n}\nclass IdSuccess<_SuccessPayloadType> {\n  type: 'ID_SUCCESS' = 'ID_SUCCESS';\n}\nclass IdFailure<_FailurePayloadType> {\n  type: 'ID_FAILURE' = 'ID_FAILURE';\n}\n\n// This ensures that we don't redefine the existing fields in the actions.\ntype NotIdLoadingAction<T> = NoIntersection<T, IdLoadAction>;\ntype NotIdSuccessAction<T> = NoIntersection<T, IdSuccessAction>;\ntype NotIdFailureAction<T> = NoIntersection<T, IdFailureAction>;\n"]}