Merge pull request #8255 from seansfkelley/redux-logger-2.6.0

Redux logger 2.6.0

redux-logger/redux-logger-tests.ts

@@ -1,21 +1,94 @@
 /// <reference path="./redux-logger.d.ts" />
 
-import createLogger from 'redux-logger';
+import * as createLogger from 'redux-logger';
 import { applyMiddleware, createStore } from 'redux'
 
 let logger = createLogger();
 
-let loggerWithOpts = createLogger({
-  actionTransformer: actn => actn,
-  collapsed: true,
+let loggerSimpleOpts = createLogger({
   duration: true,
-  level: 'error',
-  logger: console,
-  predicate: (getState, action) => true,
   timestamp: true,
-  stateTransformer: state => state
+  logger: console,
+  logErrors: true,
+  predicate: (getState, action) => true,
+  stateTransformer: (state) => state,
+  actionTransformer: (action) => action,
+  errorTransformer: (error) => error
+});
+
+let loggerCollapsedBool = createLogger({
+  collapsed: true
+});
+
+let loggerCollapsedPredicate = createLogger({
+  collapsed: (getAction, action) => true
+});
+
+let loggerColorsBoolean = createLogger({
+  colors: {
+    title: false,
+    prevState: false,
+    action: false,
+    nextState: false,
+    error: false
+  }
+});
+
+let loggerColorsFunction = createLogger({
+  colors: {
+    title: (action) => '#000',
+    prevState: (state) => '#000',
+    action: (action) => '#000',
+    nextState: (state) => '#000',
+    error: (error, prevState) => '#000'
+  }
+});
+
+let loggerLevelString = createLogger({
+  level: 'log'
+});
+
+let loggerLevelFunction = createLogger({
+  level: (action) => 'log'
+});
+
+let loggerLevelObjectFunction = createLogger({
+  level: {
+    prevState: (state) => 'log',
+    action: (action) => 'log',
+    nextState: (state) => 'log',
+    error: (error, prevState) => 'log'
+  }
+});
+
+let loggerLevelObjectBoolean = createLogger({
+  level: {
+    prevState: false,
+    action: false,
+    nextState: false,
+    error: false
+  }
+});
+
+let loggerLevelObjectString = createLogger({
+  level: {
+    prevState: 'log',
+    action: 'log',
+    nextState: 'log',
+    error: 'log'
+  }
 });
 
 let createStoreWithMiddleware = applyMiddleware(
-  logger, loggerWithOpts
+  logger,
+  loggerSimpleOpts,
+  loggerCollapsedBool,
+  loggerCollapsedPredicate,
+  loggerColorsBoolean,
+  loggerColorsFunction,
+  loggerLevelString,
+  loggerLevelFunction,
+  loggerLevelObjectFunction,
+  loggerLevelObjectBoolean,
+  loggerLevelObjectString
 )(createStore);

redux-logger/redux-logger.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for redux-logger v2.0.0
+// Type definitions for redux-logger v2.6.0
 // Project: https://github.com/fcomb/redux-logger
 // Definitions by: Alexander Rusakov <https://github.com/arusakov/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -7,16 +7,44 @@
 
 declare module 'redux-logger' {
 
-  interface ReduxLoggerOptions {
-    actionTransformer?: (action: any) => any;
-    collapsed?: boolean;
-    duration?: boolean;
-    level?: string;
-    logger?: any;
-    predicate?: (getState: Function, action: any) => boolean;
-    timestamp?: boolean;
-    stateTransformer?: (state: any) => any;
+  type LoggerPredicate = (getState: () => any, action: any) => boolean;
+
+  type StateToString = (state: any) => string;
+  type ActionToString = (action: any) => string;
+  type ErrorToString = (error: any, prevState: any) => string;
+
+  interface ColorsObject {
+    title?: boolean | ActionToString;
+    prevState?: boolean | StateToString;
+    action?: boolean | ActionToString;
+    nextState?: boolean | StateToString;
+    error?: boolean | ErrorToString;
   }
 
-  export default function createLogger(options?: ReduxLoggerOptions): Redux.Middleware;
+  interface LevelObject {
+    prevState?: string | boolean | StateToString;
+    action?: string | boolean | ActionToString;
+    nextState?: string | boolean | StateToString;
+    error?: string | boolean | ErrorToString;
+  }
+
+  interface ReduxLoggerOptions {
+    level?: string | ActionToString | LevelObject;
+    duration?: boolean;
+    timestamp?: boolean;
+    colors?: ColorsObject;
+    logger?: any;
+    logErrors?: boolean;
+    collapsed?: boolean | LoggerPredicate;
+    predicate?: LoggerPredicate;
+    stateTransformer?: (state: any) => any;
+    actionTransformer?: (action: any) => any;
+    errorTransformer?: (error: any) => any;
+  }
+
+  // Trickery to get TypeScript to accept that our anonymous, non-default export is a function.
+  // see https://github.com/Microsoft/TypeScript/issues/3612 for more
+  namespace createLogger {}
+  function createLogger(options?: ReduxLoggerOptions): Redux.Middleware;
+  export = createLogger;
 }