Enhance middleware utils

Author: Robin Bühler

README.md

@@ -76,7 +76,7 @@ Within this section additional types are explained.
 | Property        | Type                         | Description                                                 |
 |:----------------|:-----------------------------|:------------------------------------------------------------|
 | `message`       | `string`                     | Error message                                               |
-| `contraint`     | `{ unique: boolean } | { constraint: `[Constraint](#constraint)`}` | Constraint for this rule |
+| `contraint`     | `{ unique: boolean } \| { constraint: `[Constraint](#constraint)`}` | Constraint for this rule |
 
 #### Constraint
 `(value: string) => boolean`

package.json

@@ -7,7 +7,7 @@
     "react"
   ],
   "homepage": "https://openscript.github.io/react-dsv-import/",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "main": "dist/index.js",
   "module": "dist/es/index.js",
   "types": "dist/index.d.ts",

src/middlewares/middleware.test.ts

@@ -52,4 +52,31 @@ describe('middleware', () => {
     expect(middlewareBMock).toHaveBeenNthCalledWith(2, defaultState, expect.any(Function), { type: 'initialCall' });
     expect(middlewareCMock).toBeCalledTimes(2);
   });
+
+  it('should not call a middleware twice', () => {
+    const dispatchMock = jest.fn();
+    const middlewareAMock = jest.fn((_state, dispatch) => {
+      dispatch({ type: 'sequentCall' });
+    });
+    const middlewareBMock = jest.fn((_state, dispatch) => {
+      dispatch({ type: 'sequentCall' });
+    });
+    const middlewareCMock = jest.fn((_state, dispatch) => {
+      dispatch({ type: 'sequentCall' });
+    });
+    const enhancedDispatch = applyMiddlewares(
+      defaultState,
+      dispatchMock,
+      middlewareAMock,
+      middlewareBMock,
+      middlewareCMock
+    );
+    enhancedDispatch({ type: 'initialCall' });
+
+    expect(middlewareAMock).toBeCalledTimes(5);
+    expect(middlewareBMock).toBeCalledTimes(5);
+    expect(middlewareBMock).toHaveBeenNthCalledWith(1, defaultState, expect.any(Function), { type: 'sequentCall' });
+    expect(middlewareBMock).toHaveBeenNthCalledWith(2, defaultState, expect.any(Function), { type: 'sequentCall' });
+    expect(middlewareCMock).toBeCalledTimes(5);
+  });
 });

src/middlewares/middleware.ts

@@ -1,21 +1,24 @@
 import { Dispatch } from 'react';
 import { State } from '../models/state';
-
-type Middleware<T, A> = (state: State<T>, dispatch: Dispatch<A>, action: A) => void;
+import { Middleware } from '../models/middleware';
 
 export const applyMiddlewares = <T, A>(state: State<T>, dispatch: Dispatch<A>, ...middlewares: Middleware<T, A>[]) => (
   action: A
 ) => {
-  const without = (i: number) => {
-    return middlewares.filter((_, filterIndex) => i !== filterIndex);
+  const without = (nextMiddlewares: Middleware<T, A>[], i: number) => {
+    return nextMiddlewares.filter((_, filterIndex) => i !== filterIndex);
   };
 
   const next = (nextMiddlewares: Middleware<T, A>[]) => (value: A) => {
     dispatch(value);
+    call(nextMiddlewares, value);
+  };
+
+  const call = (nextMiddlewares: Middleware<T, A>[], value: A) => {
     nextMiddlewares.forEach((m, i) => {
-      m(state, next(without(i)), value);
+      m(state, next(without(nextMiddlewares, i)), value);
     });
-  };
+  }
 
-  middlewares.forEach((m, i) => m(state, next(without(i)), action));
+  call(middlewares, action);
 };

src/models/middleware.ts

@@ -0,0 +1,4 @@
+import { State } from "./state";
+import { Dispatch } from "react";
+
+export type Middleware<T, A> = (state: State<T>, dispatch: Dispatch<A>, action: A) => void;