ngrx-forms/esm2015/src/reducer.js

Proper integration of forms in Angular 4 applications using ngrx

import { ALL_NGRX_FORMS_ACTION_TYPES } from './actions';
import { formArrayReducer } from './array/reducer';
import { formControlReducer } from './control/reducer';
import { formGroupReducer } from './group/reducer';
import { isArrayState, isFormState, isGroupState } from './state';
export function formStateReducer(state, action) {
    if (!state) {
        throw new Error('The form state must be defined!');
    }
    if (!isFormState(state)) {
        throw new Error(`state must be a form state, got ${state}`);
    }
    if (isGroupState(state)) {
        return formGroupReducer(state, action);
    }
    if (isArrayState(state)) {
        return formArrayReducer(state, action);
    }
    return formControlReducer(state, action);
}
/**
 * This function creates a reducer function that first applies an action to the state
 * and afterwards applies all given update functions one after another to the resulting
 * form state. However, the update functions are only applied if the form state changed
 * as result of applying the action. If you need the update functions to be applied
 * regardless of whether the state changed (e.g. because the update function closes
 * over variables that may change independently of the form state) you can simply apply
 * the update manually (e.g. `updateFunction(formStateReducer(state, action))`).
 *
 * The following (contrived) example uses this function to create a reducer that after
 * each action validates the child control `name` to be required and sets the child
 * control `email`'s value to be `''` if the name is invalid.
 *
```typescript
interface FormValue {
  name: string;
  email: string;
}

const updateFormState = updateGroup<FormValue>(
  {
    name: validate(required),
  },
  {
    email: (email, parentGroup) =>
      parentGroup.controls.name.isInvalid
        ? setValue('', email)
        : email,
  },
);

const reducer = createFormStateReducerWithUpdate<FormValue>(updateFormState);
```
 */
export function createFormStateReducerWithUpdate(updateFnOrUpdateFnArr, ...updateFnArr) {
    updateFnArr = [...(Array.isArray(updateFnOrUpdateFnArr) ? updateFnOrUpdateFnArr : [updateFnOrUpdateFnArr]), ...updateFnArr];
    return (state, action) => {
        const newState = formStateReducer(state, action);
        return newState === state ? state : updateFnArr.reduce((s, f) => f(s), newState);
    };
}
function reduceNestedFormState(state, key, action) {
    const value = state[key];
    if (!isFormState(value)) {
        return state;
    }
    return Object.assign(Object.assign({}, state), { [key]: formStateReducer(value, action) });
}
function reduceNestedFormStates(state, action) {
    return Object.keys(state).reduce((s, key) => reduceNestedFormState(s, key, action), state);
}
/**
 * This function returns an object that can be passed to ngrx's `createReducer`
 * function (available starting with ngrx version 8). By doing this all form
 * state properties on the state will be updated whenever necessary (i.e.
 * whenever an ngrx-forms action is dispatched).
 *
 * To manually update a form state (e.g. to validate it) use
 * `wrapReducerWithFormStateUpdate`.
 */
export function onNgrxForms() {
    return {
        reducer: (state, action) => isFormState(state) ? formStateReducer(state, action) : reduceNestedFormStates(state, action),
        types: ALL_NGRX_FORMS_ACTION_TYPES,
    };
}
/**
 * Define a reducer for a ngrx-forms action. This functions works the same as
 * ngrx's `on` except that you provide the ngrx-forms action class instead of
 * your action creator as a parameter.
 */
export function onNgrxFormsAction(actionCons, reducer) {
    return {
        reducer: (state, action) => reducer(reduceNestedFormStates(state, action), action),
        types: [actionCons.TYPE],
    };
}
/**
 * This function wraps a reducer and returns another reducer that first calls
 * the given reducer and then calls the given update function for the form state
 * that is specified by the form state locator function.
 *
 * The update function is passed the form state and the updated containing state
 * as parameters.
 */
export function wrapReducerWithFormStateUpdate(reducer, formStateLocator, updateFn) {
    return (state, action) => {
        const updatedState = reducer(state, action);
        const formState = formStateLocator(updatedState);
        // if the state itself is the form state, update it directly
        if (formState === updatedState) {
            return updateFn(formState, updatedState);
        }
        const formStateKey = Object.keys(updatedState).find(key => updatedState[key] === formState);
        const updatedFormState = updateFn(formState, updatedState);
        if (updatedFormState === formState) {
            return updatedState;
        }
        return Object.assign(Object.assign({}, updatedState), { [formStateKey]: updatedFormState });
    };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reducer.js","sourceRoot":"","sources":["../../../src/reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import { Action, ActionReducer } from '@ngrx/store';\r\n\r\nimport { Actions, ALL_NGRX_FORMS_ACTION_TYPES } from './actions';\r\nimport { formArrayReducer } from './array/reducer';\r\nimport { formControlReducer } from './control/reducer';\r\nimport { formGroupReducer } from './group/reducer';\r\nimport { AbstractControlState, FormArrayState, FormControlState, FormState, isArrayState, isFormState, isGroupState, KeyValue } from './state';\r\nimport { ProjectFn } from './update-function/util';\r\n\r\nexport function formStateReducer<TValue>(\r\n  state: FormState<TValue> | AbstractControlState<TValue> | undefined,\r\n  action: Action,\r\n): FormState<TValue> {\r\n  if (!state) {\r\n    throw new Error('The form state must be defined!');\r\n  }\r\n\r\n  if (!isFormState(state)) {\r\n    throw new Error(`state must be a form state, got ${state}`);\r\n  }\r\n\r\n  if (isGroupState(state)) {\r\n    return formGroupReducer(state, action) as any;\r\n  }\r\n\r\n  if (isArrayState(state)) {\r\n    return formArrayReducer(state as FormArrayState<any>, action) as any;\r\n  }\r\n\r\n  return formControlReducer(state as FormControlState<any>, action) as any;\r\n}\r\n\r\n/**\r\n * This function creates a reducer function that first applies an action to the state\r\n * and afterwards applies all given update functions one after another to the resulting\r\n * form state. However, the update functions are only applied if the form state changed\r\n * as result of applying the action. If you need the update functions to be applied\r\n * regardless of whether the state changed (e.g. because the update function closes\r\n * over variables that may change independently of the form state) you can simply apply\r\n * the update manually (e.g. `updateFunction(formStateReducer(state, action))`).\r\n *\r\n * The following (contrived) example uses this function to create a reducer that after\r\n * each action validates the child control `name` to be required and sets the child\r\n * control `email`'s value to be `''` if the name is invalid.\r\n *\r\n```typescript\r\ninterface FormValue {\r\n  name: string;\r\n  email: string;\r\n}\r\n\r\nconst updateFormState = updateGroup<FormValue>(\r\n  {\r\n    name: validate(required),\r\n  },\r\n  {\r\n    email: (email, parentGroup) =>\r\n      parentGroup.controls.name.isInvalid\r\n        ? setValue('', email)\r\n        : email,\r\n  },\r\n);\r\n\r\nconst reducer = createFormStateReducerWithUpdate<FormValue>(updateFormState);\r\n```\r\n */\r\nexport function createFormStateReducerWithUpdate<TValue>(\r\n  updateFnOrUpdateFnArr: ProjectFn<FormState<TValue>> | ProjectFn<FormState<TValue>>[],\r\n  ...updateFnArr: ProjectFn<FormState<TValue>>[]\r\n): ActionReducer<FormState<TValue>> {\r\n  updateFnArr = [...(Array.isArray(updateFnOrUpdateFnArr) ? updateFnOrUpdateFnArr : [updateFnOrUpdateFnArr]), ...updateFnArr];\r\n  return (state: FormState<TValue> | undefined, action: Action): FormState<TValue> => {\r\n    const newState = formStateReducer(state as AbstractControlState<TValue>, action);\r\n    return newState === state ? state : updateFnArr.reduce((s, f) => f(s), newState);\r\n  };\r\n}\r\n\r\nfunction reduceNestedFormState<TState>(state: TState, key: keyof TState, action: Action): TState {\r\n  const value = state[key];\r\n\r\n  if (!isFormState(value)) {\r\n    return state;\r\n  }\r\n\r\n  return {\r\n    ...state,\r\n    [key]: formStateReducer(value, action),\r\n  };\r\n}\r\n\r\nfunction reduceNestedFormStates<TState extends KeyValue>(state: TState, action: Action): TState {\r\n  return Object.keys(state).reduce((s, key) => reduceNestedFormState(s, key as keyof TState, action), state);\r\n}\r\n\r\n/**\r\n * This function returns an object that can be passed to ngrx's `createReducer`\r\n * function (available starting with ngrx version 8). By doing this all form\r\n * state properties on the state will be updated whenever necessary (i.e.\r\n * whenever an ngrx-forms action is dispatched).\r\n *\r\n * To manually update a form state (e.g. to validate it) use\r\n * `wrapReducerWithFormStateUpdate`.\r\n */\r\nexport function onNgrxForms<TState = any>(): { reducer: ActionReducer<TState>; types: string[] } {\r\n  return {\r\n    reducer: (state, action) => isFormState(state) ? formStateReducer(state!, action) as unknown as TState : reduceNestedFormStates(state!, action),\r\n    types: ALL_NGRX_FORMS_ACTION_TYPES,\r\n  };\r\n}\r\n\r\nexport interface ActionConstructor {\r\n  new(...args: any[]): Actions<any>;\r\n  readonly TYPE: string;\r\n}\r\n\r\nexport type CreatedAction<TActionCons> = TActionCons extends new (...args: any[]) => infer TAction ? TAction : never;\r\n\r\n/**\r\n * Define a reducer for a ngrx-forms action. This functions works the same as\r\n * ngrx's `on` except that you provide the ngrx-forms action class instead of\r\n * your action creator as a parameter.\r\n */\r\nexport function onNgrxFormsAction<\r\n  TActionCons extends ActionConstructor,\r\n  TState\r\n>(\r\n  actionCons: TActionCons,\r\n  reducer: (state: TState, action: CreatedAction<TActionCons>) => TState,\r\n): { reducer: ActionReducer<TState>; types: string[] } {\r\n  return {\r\n    reducer: (state, action) => reducer(reduceNestedFormStates(state!, action), action as any),\r\n    types: [actionCons.TYPE],\r\n  };\r\n}\r\n\r\n/**\r\n * This function wraps a reducer and returns another reducer that first calls\r\n * the given reducer and then calls the given update function for the form state\r\n * that is specified by the form state locator function.\r\n *\r\n * The update function is passed the form state and the updated containing state\r\n * as parameters.\r\n */\r\nexport function wrapReducerWithFormStateUpdate<TState extends KeyValue, TFormState extends AbstractControlState<any>>(\r\n  reducer: ActionReducer<TState>,\r\n  formStateLocator: (state: TState) => TFormState,\r\n  updateFn: (formState: TFormState, state: TState) => TFormState,\r\n): ActionReducer<TState> {\r\n  return (state, action) => {\r\n    const updatedState = reducer(state, action);\r\n\r\n    const formState = formStateLocator(updatedState);\r\n\r\n    // if the state itself is the form state, update it directly\r\n    if (formState === updatedState as unknown) {\r\n      return updateFn(formState, updatedState) as unknown as TState;\r\n    }\r\n\r\n    const formStateKey = Object.keys(updatedState).find(key => updatedState[key as keyof TState] as any === formState)!;\r\n\r\n    const updatedFormState = updateFn(formState, updatedState);\r\n\r\n    if (updatedFormState === formState) {\r\n      return updatedState;\r\n    }\r\n\r\n    return {\r\n      ...updatedState,\r\n      [formStateKey]: updatedFormState,\r\n    };\r\n  };\r\n}\r\n"]}