fix(store): allow primitive types (#2967)

Closes #2966

modules/store/spec/reducer_creator.spec.ts

@@ -11,6 +11,13 @@ describe('classes/reducer', function (): void {
  describe('base', () => {
  const bar = createAction('[foobar] BAR', props<{ bar: number }>());
  const foo = createAction('[foobar] FOO', props<{ foo: number }>());
+ const withDefaultParameter = createAction(
+ '[foobar] withDefaultParameter',
+ (foo: number = 4, bar: number = 7) => ({
+ foo,
+ bar,
+ })
+ );
 
  describe('on', () => {
  it('should support reducers with multiple actions', () => {
@@ -32,7 +39,11 @@ describe('classes/reducer', function (): void {
  const fooBarReducer = createReducer(
  {} as State,
  on(foo, (state, { foo }) => ({ ...state, foo })),
- on(bar, (state, { bar }) => ({ ...state, bar }))
+ on(bar, (state, { bar }) => ({ ...state, bar })),
+ on(withDefaultParameter, (_state, { type: _, foo, bar }) => ({
+ foo,
+ bar,
+ }))
  );
 
  expect(typeof fooBarReducer).toEqual('function');
@@ -45,6 +56,30 @@ describe('classes/reducer', function (): void {
 
  state = fooBarReducer(state, bar({ bar: 54 }));
  expect(state).toEqual({ foo: 42, bar: 54 });
+
+ state = fooBarReducer(state, withDefaultParameter());
+ expect(state).toEqual({ foo: 4, bar: 7 });
+ });
+
+ it('should create a primitive reducer', () => {
+ const initialState: number = 0;
+ const setState = createAction('setState', props<{ value: number }>());
+ const resetState = createAction('resetState');
+
+ const primitiveReducer = createReducer(
+ initialState,
+ on(setState, (_state, { value }) => value),
+ on(resetState, () => initialState)
+ );
+
+ let state = primitiveReducer(undefined, { type: 'UNKNOWN' });
+ expect(state).toEqual(0);
+
+ state = primitiveReducer(state, setState({ value: 7 }));
+ expect(state).toEqual(7);
+
+ state = primitiveReducer(state, resetState);
+ expect(state).toEqual(initialState);
  });
 
  it('should support reducers with multiple actions', () => {

modules/store/spec/types/action_creator.spec.ts

@@ -92,7 +92,7 @@ describe('createAction()', () => {
  );
  });
 
- it('should allow foempt', () => {
+ it('should allow default parameters', () => {
  expectSnippet(`
  const foo = createAction('FOO', (bar = 3) => ({bar}));
  `).toSucceed();

modules/store/spec/types/reducer_creator.spec.ts

@@ -4,13 +4,61 @@ import { compilerOptions } from './utils';
 describe('createReducer()', () => {
  const expectSnippet = expecter(
  (code) => `
- import {createAction, props, on} from '@ngrx/store';
+ import {createAction, createReducer, on, props} from '@ngrx/store';
 
  ${code}
  `,
  compilerOptions()
  );
 
+ describe('createReducer()', () => {
+ it('should support objects', () => {
+ expectSnippet(`
+ interface State { name: string };
+ const initialState: State = { name: 'sarah' };
+
+ const setAction = createAction('set', props<{ value: State }>());
+ const resetAction = createAction('reset');
+
+ const reducer = createReducer(
+ initialState,
+ on(setAction, (_, { value }) => value),
+ on(resetAction, () => initialState),
+ );
+ `).toInfer('reducer', 'ActionReducer<State, Action>');
+ });
+
+ it('should support arrays', () => {
+ expectSnippet(`
+ const initialState: string[] = [];
+
+ const setAction = createAction('set', props<{ value: string[] }>());
+ const resetAction = createAction('reset');
+
+ const reducer = createReducer(
+ initialState,
+ on(setAction, (_, { value }) => value),
+ on(resetAction, () => initialState),
+ );
+ `).toInfer('reducer', 'ActionReducer<string[], Action>');
+ });
+
+ it('should support primitive types', () => {
+ expectSnippet(`
+ const initialState: number = 0;
+
+ const setAction = createAction('set', props<{ value: number }>());
+ const resetAction = createAction('reset');
+
+ const reducer = createReducer(
+ initialState,
+ on(setAction, (_, { value }) => value),
+ on(resetAction, () => initialState),
+ );
+ `).toInfer('reducer', 'ActionReducer<number, Action>');
+ });
+ });
+
  describe('on()', () => {
  it('should enforce action property types', () => {
  expectSnippet(`

modules/store/src/reducer_creator.ts

@@ -22,7 +22,9 @@ export interface ReducerTypes<
 
 // Specialized Reducer that is aware of the Action type it needs to handle
 export interface OnReducer<State, Creators extends readonly ActionCreator[]> {
- (state: State, action: ActionType<Creators[number]>): { [P in keyof State]: State[P] };
+ (state: State, action: ActionType<Creators[number]>): State extends object
+ ? { [P in keyof State]: State[P] }
+ : State;
 }
 
 /**