/// <reference path="../../typings/index.d.ts" />

import {applyMiddleware, createStore} from "redux";
import * as createLogger from "redux-logger";
import * as thunkMiddleware from "redux-thunk";
import * as reducers from "../reducers";

const loggerMiddleware: Redux.Middleware = createLogger();

export function configureStore(): Redux.Store<{}> {
  let store = createStore(reducers.rootReducer, {}, applyMiddleware(thunkMiddleware.default, loggerMiddleware));
  if (module.hot) {
    module.hot.accept("../reducers", () => {
      // tslint:disable-next-line:no-require-imports
      const nextRootreducer = require("../reducers").rootReducer;
      store.replaceReducer(nextRootreducer);
    });
  }
  return store;
}

import { createStore as createReduxStore, applyMiddleware } from "redux";
import thunk from "redux-thunk";
import * as createLogger from "redux-logger";

export const createStore = process.env.NODE_ENV === "development"
    ? applyMiddleware(thunk, createLogger({ collapsed: true }))(createReduxStore)
    : applyMiddleware(thunk)(createReduxStore);

import { createStore, applyMiddleware, compose } from 'redux';
import rootReducer from '../reducers/index';
import * as createLogger from 'redux-logger';
import thunk from 'redux-thunk';
import promiseMiddleware from 'redux-promise-middleware';
import { DevTools } from '../containers/DevTools.js';

const logger: any = createLogger();
/**
 * thunk, logger, promiseMiddleware are used as redux middleware
 *
 * uncomment logger to receive debug information in browser console
 */
const finalCreateStore = compose(
    applyMiddleware(logger, thunk, promiseMiddleware()),
    DevTools.instrument()
)(createStore);

export function configureStore(initialState) {
    return finalCreateStore(rootReducer, initialState);
};

import { flushMicrotasks } from '@angular/core/testing';

import { Iterable } from 'immutable';

import * as createLogger from 'redux-logger';

export const logger = createLogger({
  level: 'debug',
  collapsed: true,
  predicate: (getState, action) => true,
  stateTransformer:
    state => {
      const newState = new Object();

      for (const i of Object.keys(state)) {
        newState[i] = Iterable.isIterable(state[i])
          ? state[i].toJS()
          : state[i];
      };

      return newState;
    }
  });

export const simulateUserTyping = (control, text: string): Promise<void> => {
  return new Promise<void>((resolve, reject) => {
    try {
      dispatchKeyEvents(control, text);
      resolve();
    } catch (error) {
      console.error('Failed to dispatch typing events', error);

/// <reference path="../interfaces/interfaces.d.ts" />

import {createStore, applyMiddleware} from 'redux';
import * as thunk from 'redux-thunk';
import * as createLogger from 'redux-logger';

import reducer from '../reducers/rootReducer';

const logger = createLogger();

const createStoreWithMiddleware = applyMiddleware(
    thunk,
    logger
)(createStore);

export default function configureStore(initialState) {
    return createStoreWithMiddleware(reducer, initialState);
}

import thunk from 'redux-thunk';
import DevTools from '../containers/devTools';
import { rootReducer } from '../reducers';
import { hashHistory } from 'react-router';
import { persistState } from 'redux-devtools';
import { routerMiddleware } from 'react-router-redux';
import { createStore, applyMiddleware, compose } from 'redux';
import * as createLogger from 'redux-logger';
import { initialState } from './props';
const router = routerMiddleware(hashHistory);
// create logger
const logger = createLogger({
    level: 'info',
    collapsed: true,
});

const enhancer = compose(
    applyMiddleware(thunk, router, logger),
    DevTools.instrument(),
    persistState(
        window.location.href.match(
            /[?&]debug_session=([^&]+)\b/
        ))
)

export const store = createStore(rootReducer, initialState, applyMiddleware(thunk));

import * as createLogger from 'redux-logger'

const logger = createLogger({
  collapsed: true,
  stateTransformer: (state) => {
    // return immutableToJS(state);
    return state
  },
  predicate: (getState, action) => {
    const type = action.type
    return type !== 'redux-form/BLUR' &&
      type !== 'redux-form/CHANGE' &&
      type !== 'redux-form/FOCUS' &&
      type !== 'redux-form/TOUCH'
  },
});


export default logger;

/// <reference path="./redux-logger.d.ts" />

import * as createLogger from 'redux-logger';
import { applyMiddleware, createStore } from 'redux'

let logger = createLogger();

let loggerSimpleOpts = createLogger({
  duration: true,
  timestamp: true,
  logger: console,
  logErrors: true,
  predicate: (getState, action) => true,
  stateTransformer: (state) => state,
  actionTransformer: (action) => action,
  errorTransformer: (error) => error,
  diff: true,
  diffPredicate: (getState, action) => true,
});

let loggerCollapsedBool = createLogger({
  collapsed: true
});

let loggerCollapsedPredicate = createLogger({
  collapsed: (getAction, action) => true
});

let loggerColorsBoolean = createLogger({
  colors: {
    title: false,

/*
 * @param {Object} initial state to bootstrap our stores with for server-side rendering
 * @param {History Object} a history object. We use `createMemoryHistory` for server-side rendering,
 *                          while using browserHistory for client-side
 *                          rendering.
 */
export default function configureStore(initialState, history) {
  let middleware = [ thunk, promiseMiddleware ];
  // Installs hooks that always keep react-router and redux
  // store in sync
  const reactRouterReduxMiddleware = routerMiddleware(history);
  if (__DEV__) {
    middleware.push(reactRouterReduxMiddleware, createLogger());
  } else {
    middleware.push(reactRouterReduxMiddleware);
  }

  const finalCreateStore = applyMiddleware(...middleware)(createStore);

  const store = finalCreateStore(rootReducer, initialState);

  if ((module as any).hot) {
    // Enable Webpack hot module replacement for reducers
    (module as any).hot.accept('reducers', () => {
      const nextReducer = require('reducers');
      store.replaceReducer(nextReducer);
    });
  }

  return store;
}

const configureStore = ({reducer, devMode, throttle}) => {

  const middlewares = [thunk];

  // use logger if devMode
  if (devMode) {
    const logger = createLogger();
    middlewares.push(logger);
  } else {
    process.env.NODE_ENV = 'production';
  }

  // throttle save
  if (throttle) {
    const toThrottle = Object.keys(throttle);
    toThrottle.forEach((action: string) => {
        middlewares.push(
          throttleActions([].concat(action), throttle[action])
        );
    });
  }

  // create store with middlewares
  const store: Redux.Store = createStore(
    reducer,
    applyMiddleware(...middlewares)
  );

  return store;
};

export default () => {
    const logger = createLogger({
        collapsed: true,
        level: 'info',
        duration: true
    })
    return createStore(rootReducer, applyMiddleware(thunk.default, logger))
}

  constructor(
    private ngRedux: NgRedux<IAppState>,
    private devTool: DevToolsExtension) {

    this.ngRedux.configureStore(
      rootReducer,
      {},
      [ createLogger() ],
      [ ...enhancers, devTool.isEnabled() ? devTool.enhancer() : f => f]);
  }

// chartId is only used for memoization.
function _createStore(chartId?: ChartId) {
  let middlewares: Redux.Middleware[] = [
    createDebounced(),
    ThunkMiddleware
  ];

  if (process.env.NODE_ENV === 'development') {
    middlewares.push(createLogger({
      actionTransformer: (action) => _.defaults({
        type: ActionType[ action.type ] || action.type
      }, action),
      collapsed: true
    }));
  }

  return applyMiddleware(...middlewares)(createStore)(reducer);
}

 export function configureStore(initialState:IAppState) {
     debugger
     const store = createStore(
         reducers, 
         initialState,
         compose(applyMiddleware(
             thunk,
             createLogger()
         ), DevTools.instrument())
     );
     
     if (module.hot) {
         module.hot.accept('../../src/reducers', () => {
             const nextRootReducer:Reducer = require('../../src/reducers/index.ts')['default'];
             store.replaceReducer(nextRootReducer);
         })
     }
     return store;
 }

export default function configureStore(preloadedState): Redux.Store {

  const store = createStore(
    rootReducer,
    preloadedState,
    compose(
      applyMiddleware(thunk, createLogger() ),
      applyMiddleware(routerMiddleware(hashHistory)),
      typeof window === 'object' && typeof window.devToolsExtension !== 'undefined' ? window.devToolsExtension() : f => f
    )
  );

  if (module.hot) {
    // Enable Webpack hot module replacement for reducers
    module.hot.accept('../reducers.ts', () => {
      const nextRootReducer = require('../reducers.ts').default;
      store.replaceReducer(nextRootReducer);
    });
  }
  return store;
}

function config($ngReduxProvider) {
  $ngReduxProvider.createStoreWith(rootReducer, [thunk, createLogger()])
}

// `analyticsTracker` is Google Analytics. It's an argument here simply to allow injection
// in testing:
export default function getConfiguredStore(inputTracker: Function = null) {

  function createTracker(analyticsAction: IAnalyticsAction<any>) {
    const {
      type,
      payload: {
        info
      }
    } = analyticsAction;

    // This weird contraption is needed because:
    // - We need to be able to inject a spy as a tracking function for testing so the tracking
    // function can't be harccoded as `ga` all the time.
    // - The `ga` function is defined twice in the app's lifetime. The first time, it is
    // defined synchronously at the location of the google analytics snippet
    // (so before the execution of the main app code.).
    // However, this function doesn't actually send anything to GA. The `ga` function
    // is then subsequently redefined by the `analytics.js` script loaded from `google-analytics.com`.
    // This is the tracking function we want. The only problem is that the `script` tag for that
    // `analytics.js` script is `async` so the redefinition happens after the app code has initialized.
    // Thus, we can't just set `ga` as the default value for the `inputTracker` argument.
    const actualTrackingFunction = (inputTracker === null) ? ga : inputTracker;

    // If the payload's data is a primitive type, just send it. Otherwise,
    // convert to JSOn string before sending:
    const eventLabel = _.isObject(info) ? JSON.stringify(info) : info;

    actualTrackingFunction('send', {
      hitType: 'event',
      eventCategory: 'interaction',
      eventAction: type,
      eventLabel
    })
  }
  const analyticsMiddleware = reduxAnalytics(createTracker) as Middleware

  let middlewares: Middleware[];
  try {
    if (process.env.NODE_ENV === 'development') {
      // Add logger middleware in dev mode only:
      middlewares = [thunk as Middleware, createLogger() as Middleware];
    } else if (process.env.NODE_ENV === 'test') {
      // Include analytics for for unit testing:
      middlewares = [thunk as Middleware, analyticsMiddleware];
    } else {
      // Of course, analytics in production:
      middlewares = [thunk as Middleware, analyticsMiddleware];
    }
  } catch(e) {
    if (e.name === 'ReferenceError') {
      console.log(e);
      console.log('Must define the value of process.env.NODE_ENV global variable in webpack config. Treat as "development" for now.');
      middlewares = [thunk as Middleware, createLogger() as Middleware];
    } else {
      throw e;
    }
  }

  const enhancers = applyMiddleware(...middlewares);

  // Redux store:
  const store = createStore<IStoreState>(
    reducer, {
      // Let the store start out with an empty list of items:
      items: undefined,
      fetchStatus: undefined
  } as IStoreState, enhancers)

  // Persist the state to `localStorage` whenever the state changes but not more
  // often than every 2 seconds:
  // store.subscribe(_.throttle((state: IStoreState) => {
  //   saveLocalState(state);
  // }, 2000));
  return store;
}

export default function configureStore() {
  const store = createStore(reducers, compose(applyMiddleware(epicMiddleware, createLogger())));
  return store;
}