import { Link, NavLink, Redirect, withRouter, Route } from 'react-router-dom';
import React from 'react';
import Loadable from 'react-loadable';
import history from '@@/history';
export * from '@@/umiExports';

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

// ref: https://github.com/zeit/next.js/blob/canary/lib/dynamic.js

function dynamic (dynamicOptions, options) {
  var loadableFn = Loadable;
  var loadableOptions = {
    loading: function loading(_ref) {
      var error = _ref.error,
          isLoading = _ref.isLoading;

      if (process.env.NODE_ENV === 'development') {
        if (isLoading) {
          return /*#__PURE__*/React.createElement("p", null, "loading...");
        }

        if (error) {
          return /*#__PURE__*/React.createElement("p", null, error.message, /*#__PURE__*/React.createElement("br", null), error.stack);
        }
      }

      return /*#__PURE__*/React.createElement("p", null, "loading...");
    }
  }; // Support for direct import(),
  // eg: dynamic(import('../hello-world'))

  if (typeof dynamicOptions.then === 'function') {
    loadableOptions.loader = function () {
      return dynamicOptions;
    }; // Support for having first argument being options,
    // eg: dynamic({loader: import('../hello-world')})

  } else if (_typeof(dynamicOptions) === 'object') {
    loadableOptions = _objectSpread2({}, loadableOptions, {}, dynamicOptions);
  } // Support for passing options,
  // eg: dynamic(import('../hello-world'), {loading: () => <p>Loading something</p>})


  loadableOptions = _objectSpread2({}, loadableOptions, {}, options); // Support for `render` when using a mapping,
  // eg: `dynamic({ modules: () => {return {HelloWorld: import('../hello-world')}, render(props, loaded) {} } })

  if (dynamicOptions.render) {
    loadableOptions.render = function (loaded, props) {
      return dynamicOptions.render(props, loaded);
    };
  } // Support for `modules` when using a mapping,
  // eg: `dynamic({ modules: () => {return {HelloWorld: import('../hello-world')}, render(props, loaded) {} } })


  if (dynamicOptions.modules) {
    loadableFn = Loadable.Map;
    var loadModules = {};
    var modules = dynamicOptions.modules();
    Object.keys(modules).forEach(function (key) {
      var value = modules[key];

      if (typeof value.then === 'function') {
        loadModules[key] = function () {
          return value.then(function (mod) {
            return mod.default || mod;
          });
        };

        return;
      }

      loadModules[key] = value;
    });
    loadableOptions.loader = loadModules;
  }

  return loadableFn(loadableOptions);
}

/* global window */
function push() {
  history.push.apply(history, arguments);
}
function replace() {
  history.replace.apply(history, arguments);
}
function go() {
  history.go.apply(history, arguments);
}
function goBack() {
  history.goBack.apply(history, arguments);
}
function goForward() {
  history.goForward.apply(history, arguments);
}
var router = {
  push: push,
  replace: replace,
  go: go,
  goBack: goBack,
  goForward: goForward
};

export { Link, NavLink, Redirect, Route, dynamic, router, withRouter };