index.js

var _excluded = ["render", "component", "path", "exact", "strict", "sensitive", "children"],
    _excluded2 = ["children"];

function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }

function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }

import React, { cloneElement, createElement, useEffect, useRef, useState } from 'react';
import PropTypes from 'prop-types';
import { Route, Switch, matchPath, useLocation } from 'react-router-dom';
import TransitionMotion from '@serprex/react-motion/lib/TransitionMotion';
import spring from '@serprex/react-motion/lib/spring'; // Helpers

function ensureSpring(styles) {
  var obj = {};

  for (var key in styles) {
    var value = styles[key];

    if (typeof value === 'number') {
      obj[key] = spring(value);
    } else {
      obj[key] = value;
    }
  }

  return obj;
}

function identity(v) {
  return v;
}

function noop() {} // Components


function RouteTransition(_ref) {
  var children = _ref.children,
      className = _ref.className,
      atEnter = _ref.atEnter,
      atActive = _ref.atActive,
      atLeave = _ref.atLeave,
      _ref$wrapperComponent = _ref.wrapperComponent,
      wrapperComponent = _ref$wrapperComponent === void 0 ? 'div' : _ref$wrapperComponent,
      _ref$didLeave = _ref.didLeave,
      didLeave = _ref$didLeave === void 0 ? noop : _ref$didLeave,
      _ref$mapStyles = _ref.mapStyles,
      mapStyles = _ref$mapStyles === void 0 ? identity : _ref$mapStyles,
      _ref$runOnMount = _ref.runOnMount,
      runOnMount = _ref$runOnMount === void 0 ? false : _ref$runOnMount;
  var defaultStyles = runOnMount === false ? null : children == undefined ? [] : [{
    key: children.key,
    data: children,
    style: atEnter
  }];
  var styles = children == undefined ? [] : [{
    key: children.key,
    data: children,
    style: ensureSpring(atActive)
  }];
  return /*#__PURE__*/React.createElement(TransitionMotion, {
    defaultStyles: defaultStyles,
    styles: styles,
    willEnter: function willEnter() {
      return atEnter;
    },
    willLeave: function willLeave() {
      return ensureSpring(atLeave);
    },
    didLeave: didLeave
  }, function (interpolatedStyles) {
    return /*#__PURE__*/React.createElement("div", {
      className: className
    }, interpolatedStyles.map(function (config) {
      var props = {
        style: mapStyles(config.style),
        key: config.key
      };
      return wrapperComponent !== false ? /*#__PURE__*/createElement(wrapperComponent, props, config.data) : /*#__PURE__*/cloneElement(config.data, props);
    }));
  });
}

RouteTransition.propTypes = {
  className: PropTypes.string,
  wrapperComponent: PropTypes.oneOfType([PropTypes.bool, PropTypes.element, PropTypes.string, PropTypes.func]),
  atEnter: PropTypes.object.isRequired,
  atActive: PropTypes.object.isRequired,
  atLeave: PropTypes.object.isRequired,
  didLeave: PropTypes.func,
  mapStyles: PropTypes.func,
  runOnMount: PropTypes.bool
}; // AnimatedRoute
// The key-getter for RouteTransition. It's either on or off.

function getKey(_ref2, path, exact) {
  var pathname = _ref2.pathname;
  return matchPath(pathname, {
    exact: exact,
    path: path
  }) ? 'match' : 'no-match';
}

function AnimatedRoute(_ref3) {
  var render = _ref3.render,
      component = _ref3.component,
      path = _ref3.path,
      exact = _ref3.exact,
      strict = _ref3.strict,
      sensitive = _ref3.sensitive,
      children = _ref3.children,
      routeTransitionProps = _objectWithoutProperties(_ref3, _excluded);

  var location = useLocation();
  return /*#__PURE__*/React.createElement(RouteTransition, routeTransitionProps, /*#__PURE__*/React.createElement(Route, {
    key: getKey(location, path, exact),
    path: path,
    exact: exact,
    strict: strict,
    sensitive: sensitive,
    location: location,
    component: component,
    render: render,
    children: children
  }));
} // AnimatedSwitch


var NO_MATCH = {
  key: 'no-match'
}; // Not every location object has a `key` property (e.g. HashHistory).

function getLocationKey(location) {
  return typeof location.key === 'string' ? location.key : '';
} // Some superfluous work, but something we need to do in order
// to persist matches/allow for nesting/etc.


function getMatchedRoute(children, _ref4) {
  var pathname = _ref4.pathname;
  var childrenArray = React.Children.toArray(children);

  for (var i = 0; i < childrenArray.length; i++) {
    var child = childrenArray[i];
    var matches = null;

    try {
      matches = matchPath(pathname, {
        exact: child.props.exact,
        path: child.props.path
      });
    } catch (e) {
      matches = null;
    }

    if (matches) {
      return child;
    }
  }

  return NO_MATCH;
}

var counter = 0;

function AnimatedSwitch(_ref5) {
  var children = _ref5.children,
      routeTransitionProps = _objectWithoutProperties(_ref5, _excluded2);

  var location = useLocation();
  var match = useRef(null);
  var key = useRef(null);
  var nextMatch = getMatchedRoute(children, location);

  if (match.current === null) {
    // Persist a reference to the most recent match
    match.current = nextMatch;
    key.current = getLocationKey(location);
  } else if (match.current.key !== nextMatch.key) {
    // Update the key given to Switch anytime the matched route changes
    match.current = nextMatch;
    key.current = getLocationKey(location) + ++counter;
  }

  return /*#__PURE__*/React.createElement(RouteTransition, routeTransitionProps, /*#__PURE__*/React.createElement(Switch, {
    key: key.current,
    location: location
  }, children));
}

export { ensureSpring, spring, RouteTransition, AnimatedRoute, AnimatedSwitch };