feat: 🎸 Rename reduceDetectors to composeDetectors

Rename reduceDetectors to composeDetectors in order to follow community
naming conventions (combine, compose, pipe).

BREAKING CHANGE: 🧨 Renamed function `reduceDetectors` to `composeDetectors`.

Author: Piotr Oleś

README.md

@@ -37,13 +37,13 @@ const store = createStore(rootReducer, createDetectorEnhancer(rootDetector));
 ## Motivation
 
 Redux Detector [enhancer](http://redux.js.org/docs/api/createStore.html) allows you to detect state changes in redux.
-A detector is a simple and pure function which compares two states and returns action or list of actions for some states transitions.
+An actions detector is a simple and pure function which compares two states and returns action or list of actions for some states transitions.
 
 ```typescript
-type Detector<S> = (
-  prevState: S | undefined,
-  nextState: S | undefined
-) => Action | Action[] | void;
+type ActionsDetector<TState, TAction extends Action = AnyAction> = (
+  prevState: TState | undefined,
+  nextState: TState | undefined
+) => TAction | TAction[] | void;
 ```
 
 For example detector that checks if number of rows exceed 100 looks like this:
@@ -61,12 +61,12 @@ Thanks to detectors purity they are predictable and easy to test. There is no pr
 
 ## Composition
 
-Redux store can handle only one detector (and one reducer). But don't worry - you can combine and reduce them. To do this, use
-`combineDetectors` and `reduceDetectors` functions.
+Redux store can handle only one detector (and one reducer). But don't worry - you can combine and compose them. To do this, use
+`combineDetectors` and `composeDetectors` functions.
 
 ```js
 // ./detectors/rootDetector.js
-import { combineDetectors, reduceDetectors } from "redux-detector";
+import { combineDetectors, composeDetectors } from "redux-detector";
 import { fooDetector } from "./fooDetector";
 import { barDetector } from "./barDetector";
 import { anotherDetector } from "./anotherDetector";
@@ -81,7 +81,7 @@ import { anotherDetector } from "./anotherDetector";
 // and also `barDetector` to `state.bar` branch.
 
 export default combineDetectors({
-  foo: reduceDetectors(fooDetector, anotherDetector),
+  foo: composeDetectors(fooDetector, anotherDetector),
   bar: barDetector
 });
 ```

src/index.ts

@@ -7,6 +7,6 @@ export { DetectableStoreExt } from "./DetectableStoreExt";
 export { createDetectorEnhancer } from "./createDetectorEnhancer";
 
 // standard library
-export { reduceDetectors } from "./lib/reduceDetectors";
+export { composeDetectors } from "./lib/composeDetectors";
 export { combineDetectors } from "./lib/combineDetectors";
 export { mountDetector } from "./lib/mountDetector";

src/lib/reduceDetectors.ts renamed to src/lib/composeDetectors.ts

@@ -4,7 +4,7 @@ import { ActionsDetector } from "../Detector";
 /**
  * Compose many action detectors into one detector that aggregates actions returned by given detectors
  */
-export function reduceDetectors<TState, TAction extends Action = AnyAction>(
+export function composeDetectors<TState, TAction extends Action = AnyAction>(
   ...detectors: ActionsDetector<TState, TAction>[]
 ): ActionsDetector<TState, TAction> {
   // check detectors types in runtime
@@ -16,15 +16,15 @@ export function reduceDetectors<TState, TAction extends Action = AnyAction>(
     throw new Error(
       `Invalid ${invalidDetectorsIndexes.join(
         ", "
-      )} arguments in reduceDetectors function.\n` +
+      )} arguments in composeDetectors function.\n` +
         `Detectors should be a 'function' type, ` +
         `'${invalidDetectorsIndexes
           .map(index => typeof detectors[index])
           .join(`', '`)}' types passed.`
     );
   }
 
-  return function reducedDetector(
+  return function composedDetector(
     prevState: TState | undefined,
     nextState: TState | undefined
   ): any[] {

test/reduceDetectors.spec.ts renamed to test/composeDetectors.spec.ts

@@ -1,8 +1,8 @@
-import { reduceDetectors } from "../src";
+import { composeDetectors } from "../src";
 
-describe("reduceDetectors", () => {
+describe("composeDetectors", () => {
   it("should export composeDetectors function", () => {
-    expect(reduceDetectors).toBeInstanceOf(Function);
+    expect(composeDetectors).toBeInstanceOf(Function);
   });
 
   it("should return valid detector for composition of two detectors", () => {
@@ -14,7 +14,7 @@ describe("reduceDetectors", () => {
       return [{ type: "ACTION_C" }];
     }
 
-    const detectorAB = reduceDetectors(detectorA, detectorB);
+    const detectorAB = composeDetectors(detectorA, detectorB);
 
     expect(detectorAB).toBeInstanceOf(Function);
     expect(detectorAB({}, {})).toBeInstanceOf(Array);
@@ -49,7 +49,7 @@ describe("reduceDetectors", () => {
       return [];
     }
 
-    const detectorAB = reduceDetectors(detectorA, detectorB);
+    const detectorAB = composeDetectors(detectorA, detectorB);
 
     expect(detectorAB(-10, 50)).toEqual([{ type: "NEXT_STATE_GREATER" }]);
     expect(detectorAB(30, 20)).toEqual([{ type: "PREV_STATE_GREATER" }]);
@@ -68,7 +68,7 @@ describe("reduceDetectors", () => {
       }
     }
 
-    const detectorAB = reduceDetectors(detectorA, detectorB);
+    const detectorAB = composeDetectors(detectorA, detectorB);
 
     expect(detectorAB(-10, 50)).toEqual([{ type: "NEXT_STATE_GREATER" }]);
     expect(detectorAB(30, 20)).toEqual([{ type: "PREV_STATE_GREATER" }]);
@@ -83,7 +83,7 @@ describe("reduceDetectors", () => {
       return { type: "SINGLE_DETECTOR" };
     }
 
-    const detectorAB = reduceDetectors(detectorA, detectorB);
+    const detectorAB = composeDetectors(detectorA, detectorB);
 
     expect(detectorAB(undefined, undefined)).toEqual([
       { type: "ARRAY_DETECTOR" },
@@ -92,18 +92,18 @@ describe("reduceDetectors", () => {
   });
 
   it("should return valid composed detector for empty arguments", () => {
-    const emptyDetector = reduceDetectors();
+    const emptyDetector = composeDetectors();
 
     expect(emptyDetector).toBeInstanceOf(Function);
     expect(emptyDetector(10, 20)).toEqual([]);
   });
 
   it("should throw an exception for invalid arguments", () => {
     expect(() => {
-      (reduceDetectors as any)({ foo: "bar" });
+      (composeDetectors as any)({ foo: "bar" });
     }).toThrow();
     expect(() => {
-      (reduceDetectors as any)(() => undefined, undefined);
+      (composeDetectors as any)(() => undefined, undefined);
     }).toThrow();
   });
 });