export function history (options?: HistoryOptions) {
  const h = createHistory(options);

  const push = (l: LocationDescriptor) => h.push(l);
  const replace = (l: LocationDescriptor) => h.replace(l);

  const stream = new Stream(new HistorySource(h));

  return {push, replace, stream};
}

describe('Page', () => {
  const { pathname, search } = window.location;
  const history = createHistory();
  let page: Page;
  let spy;

  beforeEach(() => {
    spy = sinon.spy();
    page = new Page();
  });

  afterEach(() => {
    spy.reset();
  });

  it('should instantiate with an observable property', () => {
    page.should.be.an.instanceof(Page);
    page.observable.should.exist;
  });

  it('should have a current url at instantiation', () => {
    page.currentURL.should.be.an('object');
    page.currentURL.should.have.property('simple');
  });

  describe('.getCurrentURL', () => {
    it('should return a ParsedURL object', () => {
      Page.getCurrentURL().should.have.property('simple');
    });

    it('should use the Page.documentURL as a proxy to document.URL', () => {
      spy = sinon.spy(Page, 'documentURL');
      Page.getCurrentURL();
      spy.should.have.been.calledOnce;
    });
  });

  describe('.documentURL', () => {
    it('should return a string', () => {
      Page.documentURL().should.be.a('string');
    });

    it('should allow overriding', () => {
      const override: string = 'https://test.com/awesome';
      Page.documentURL(override).should.equal(override);
    });
  });

  describe('.getCurrentURL', () => {
    it('should return a ParsedURL object', () => {
      Page.getCurrentURL().should.have.property('simple');
    });
  });
});

import { createHistory, createLocation, useBeforeUnload, useQueries, useBasename } from 'history'
import { getUserConfirmation } from 'history/lib/DOMUtils'

interface Promise<T> {
    then<TResult>(onfulfilled?: (value: T) => TResult): Promise<TResult>;
}

let doSomethingAsync: () => Promise<Function>;
let input = { value: "" };

{
    let history = createHistory()

    // Listen for changes to the current location. The
    // listener is called once immediately.
    let unlisten = history.listen(function(location) {
        console.log(location.pathname)
    })

    // When you're finished, stop the listener.
    unlisten()

    // Push a new entry onto the history stack.
    history.push('/home')

    // Replace the current entry on the history stack.
    history.replace('/profile')

    // Push a new entry with state onto the history stack.

import { createStore, combineReducers, applyMiddleware } from 'redux';
import { createHistory } from 'history';
import { syncHistory, routeReducer } from 'react-router-redux';

const reducer = combineReducers({ routing: routeReducer });

// Sync dispatched route actions to the history
const browserHistory = createHistory()
const reduxRouterMiddleware = syncHistory(browserHistory);
const createStoreWithMiddleware = applyMiddleware(reduxRouterMiddleware)(createStore);

const store = createStoreWithMiddleware(reducer);

// Required for replaying actions from devtools to
reduxRouterMiddleware.listenForReplays(store);

import 'bootstrap';
import 'bootstrap/dist/css/bootstrap.css';
import './css/site.css';
import * as ko from 'knockout';
import { createHistory } from 'history';
import './webpack-component-loader';

// Load and register the <app-root> component
ko.components.register('app-root', require('./components/app-root/app-root').default);

// Tell Knockout to start up an instance of your application
ko.applyBindings({ history: createHistory() });

// Basic hot reloading support. Automatically reloads and restarts the Knockout app each time
// you modify source files. This will not preserve any application state other than the URL.
declare var module: any;
if (module.hot) {
    module.hot.accept();
    module.hot.dispose(() => ko.cleanNode(document.body));
}

//Redux
import { applyMiddleware, compose, createStore, combineReducers } from 'redux';
import thunkMiddleware from 'redux-thunk';

//Router
import {
    syncHistory, routeReducer
} from 'react-router-redux';
import { createHistory } from 'history'
import {rootReducer} from './reducers/rootReducer.ts';
import {DevTools} from './DevTools.tsx';

export const history = createHistory();

const middleware = syncHistory(history);
const reducer = combineReducers(Object.assign({}, {data: rootReducer}, {
    routing: routeReducer
}));

const finalCreateStore = compose(
    applyMiddleware(middleware, thunkMiddleware),
    DevTools.instrument()
)(createStore);

export const store = finalCreateStore(reducer);
middleware.listenForReplays(store);