react-transition-state 1.2.0-alpha.0 → 1.2.0-alpha.3

package/dist/{index.js → cjs/index.js}

@@ -12,6 +12,14 @@ var EXITING = 4;
 var EXITED = 5;
 var UNMOUNTED = 6;
 var STATES = ['preEnter', 'entering', 'entered', 'preExit', 'exiting', 'exited', 'unmounted'];
+var getFullState = function getFullState(_state) {
+  return {
+    _state: _state,
+    state: STATES[_state],
+    isEnter: _state < PRE_EXIT,
+    isMounted: _state !== UNMOUNTED
+  };
+};
 var startOrEnd = function startOrEnd(unmounted) {
   return unmounted ? UNMOUNTED : EXITED;
 };
@@ -111,72 +119,100 @@ var useTransition = function useTransition(_temp) {
   return [STATES[state], toggle, endTransition];
 };
 
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
 var initialStateMap = new Map();
 var initialConfigMap = new Map();
 
 var updateState = function updateState(_ref) {
-  var item = _ref.item,
+  var key = _ref.key,
       _state = _ref.newState,
       setStateMap = _ref.setStateMap,
       latestStateMap = _ref.latestStateMap,
       timeoutId = _ref.timeoutId,
       onChange = _ref.onChange;
   clearTimeout(timeoutId);
-  var state = {
-    state: STATES[_state],
-    _state: _state
-  };
+  var state = getFullState(_state);
   var stateMap = new Map(latestStateMap.current);
-  stateMap.set(item, state);
+  stateMap.set(key, state);
   setStateMap(stateMap);
   latestStateMap.current = stateMap;
-  onChange && onChange(item, state);
+  onChange && onChange(_extends({
+    key: key
+  }, state));
 };
 
-var useTransitionMap = function useTransitionMap() {
+var useTransitionMap = function useTransitionMap(_temp) {
+  var _ref2 = _temp === void 0 ? {} : _temp,
+      singleEnter = _ref2.singleEnter;
+
   var _useState = react.useState(initialStateMap),
       stateMap = _useState[0],
       setStateMap = _useState[1];
 
   var latestStateMap = react.useRef(stateMap);
   var configMap = react.useRef(initialConfigMap);
-  var addItem = react.useCallback(function (item, config) {
-    var initialEntered = config.initialEntered,
-        mountOnEnter = config.mountOnEnter;
+  var setItem = react.useCallback(function (key, config) {
+    if (config === void 0) {
+      config = {};
+    }
+
+    var _config = config,
+        initialEntered = _config.initialEntered,
+        mountOnEnter = _config.mountOnEnter;
     var newState = initialEntered ? ENTERED : startOrEnd(mountOnEnter);
     updateState({
-      item: item,
+      key: key,
       newState: newState,
       setStateMap: setStateMap,
       latestStateMap: latestStateMap
     });
-    configMap.current.set(item, config);
+    configMap.current.set(key, _extends({}, config));
   }, []);
-  var removeItem = react.useCallback(function (item) {
+  var deleteItem = react.useCallback(function (key) {
     var newStateMap = new Map(latestStateMap.current);
 
-    if (newStateMap.delete(item)) {
+    if (newStateMap.delete(key)) {
       setStateMap(newStateMap);
       latestStateMap.current = newStateMap;
-      configMap.current.delete(item);
+      configMap.current.delete(key);
+      return true;
     }
+
+    return false;
   }, []);
-  var endTransition = react.useCallback(function (item) {
-    var stateObj = latestStateMap.current.get(item);
+  var endTransition = react.useCallback(function (key) {
+    var stateObj = latestStateMap.current.get(key);
 
     if (!stateObj) {
-      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid item key for " + item);
+      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid key: " + key);
       return;
     }
 
-    var _configMap$current$ge = configMap.current.get(item),
+    var _configMap$current$ge = configMap.current.get(key),
         timeoutId = _configMap$current$ge.timeoutId,
         onChange = _configMap$current$ge.onChange,
         unmountOnExit = _configMap$current$ge.unmountOnExit;
 
     var newState = getEndState(stateObj._state, unmountOnExit);
     newState && updateState({
-      item: item,
+      key: key,
       newState: newState,
       setStateMap: setStateMap,
       latestStateMap: latestStateMap,
@@ -184,15 +220,15 @@ var useTransitionMap = function useTransitionMap() {
       onChange: onChange
     });
   }, []);
-  var toggle = react.useCallback(function (item, toEnter) {
-    var stateObj = latestStateMap.current.get(item);
+  var toggle = react.useCallback(function (key, toEnter) {
+    var stateObj = latestStateMap.current.get(key);
 
     if (!stateObj) {
-      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid item key for " + item);
+      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid key: " + key);
       return;
     }
 
-    var config = configMap.current.get(item);
+    var config = configMap.current.get(key);
     var _config$enter = config.enter,
         enter = _config$enter === void 0 ? true : _config$enter,
         _config$exit = config.exit,
@@ -206,7 +242,7 @@ var useTransitionMap = function useTransitionMap() {
 
     var transitState = function transitState(newState) {
       updateState({
-        item: item,
+        key: key,
         newState: newState,
         setStateMap: setStateMap,
         latestStateMap: latestStateMap,
@@ -221,13 +257,13 @@ var useTransitionMap = function useTransitionMap() {
       switch (newState) {
         case ENTERING:
           if (enterTimeout >= 0) config.timeoutId = setTimeout(function () {
-            return endTransition(item);
+            return endTransition(key);
           }, enterTimeout);
           break;
 
         case EXITING:
           if (exitTimeout >= 0) config.timeoutId = setTimeout(function () {
-            return endTransition(item);
+            return endTransition(key);
           }, exitTimeout);
           break;
 
@@ -246,19 +282,22 @@ var useTransitionMap = function useTransitionMap() {
     if (toEnter) {
       if (!enterStage) {
         transitState(enter ? preEnter ? PRE_ENTER : ENTERING : ENTERED);
+        singleEnter && latestStateMap.current.forEach(function (_, _key) {
+          return _key !== key && toggle(_key, false);
+        });
       }
     } else {
       if (enterStage) {
         transitState(exit ? preExit ? PRE_EXIT : EXITING : startOrEnd(unmountOnExit));
       }
     }
-  }, [endTransition]);
+  }, [endTransition, singleEnter]);
   return {
     stateMap: stateMap,
     toggle: toggle,
     endTransition: endTransition,
-    addItem: addItem,
-    removeItem: removeItem
+    setItem: setItem,
+    deleteItem: deleteItem
   };
 };
 

package/dist/es/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,19 @@
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+export { _extends as extends };

package/dist/es/hooks/useTransition.js

@@ -0,0 +1,85 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { ENTERED, startOrEnd, getTimeout, getEndState, PRE_EXIT, EXITING, STATES, PRE_ENTER, ENTERING } from './utils.js';
+
+var updateState = function updateState(state, setState, latestState, timeoutId, onChange) {
+  clearTimeout(timeoutId.current);
+  setState(state);
+  latestState.current = state;
+  onChange && onChange({
+    state: STATES[state]
+  });
+};
+
+var useTransition = function useTransition(_temp) {
+  var _ref = _temp === void 0 ? {} : _temp,
+      _ref$enter = _ref.enter,
+      enter = _ref$enter === void 0 ? true : _ref$enter,
+      _ref$exit = _ref.exit,
+      exit = _ref$exit === void 0 ? true : _ref$exit,
+      preEnter = _ref.preEnter,
+      preExit = _ref.preExit,
+      timeout = _ref.timeout,
+      initialEntered = _ref.initialEntered,
+      mountOnEnter = _ref.mountOnEnter,
+      unmountOnExit = _ref.unmountOnExit,
+      onChange = _ref.onChange;
+
+  var _useState = useState(initialEntered ? ENTERED : startOrEnd(mountOnEnter)),
+      state = _useState[0],
+      setState = _useState[1];
+
+  var latestState = useRef(state);
+  var timeoutId = useRef();
+
+  var _getTimeout = getTimeout(timeout),
+      enterTimeout = _getTimeout[0],
+      exitTimeout = _getTimeout[1];
+
+  var endTransition = useCallback(function () {
+    var newState = getEndState(latestState.current, unmountOnExit);
+    newState && updateState(newState, setState, latestState, timeoutId, onChange);
+  }, [onChange, unmountOnExit]);
+  var toggle = useCallback(function (toEnter) {
+    var transitState = function transitState(newState) {
+      updateState(newState, setState, latestState, timeoutId, onChange);
+
+      switch (newState) {
+        case ENTERING:
+          if (enterTimeout >= 0) timeoutId.current = setTimeout(endTransition, enterTimeout);
+          break;
+
+        case EXITING:
+          if (exitTimeout >= 0) timeoutId.current = setTimeout(endTransition, exitTimeout);
+          break;
+
+        case PRE_ENTER:
+        case PRE_EXIT:
+          timeoutId.current = setTimeout(function () {
+            return transitState(newState + 1);
+          }, 0);
+          break;
+      }
+    };
+
+    var enterStage = latestState.current <= ENTERED;
+    if (typeof toEnter !== 'boolean') toEnter = !enterStage;
+
+    if (toEnter) {
+      if (!enterStage) {
+        transitState(enter ? preEnter ? PRE_ENTER : ENTERING : ENTERED);
+      }
+    } else {
+      if (enterStage) {
+        transitState(exit ? preExit ? PRE_EXIT : EXITING : startOrEnd(unmountOnExit));
+      }
+    }
+  }, [endTransition, onChange, enter, exit, preEnter, preExit, enterTimeout, exitTimeout, unmountOnExit]);
+  useEffect(function () {
+    return function () {
+      return clearTimeout(timeoutId.current);
+    };
+  }, []);
+  return [STATES[state], toggle, endTransition];
+};
+
+export { useTransition };

package/dist/es/hooks/useTransitionMap.js

@@ -0,0 +1,169 @@
+import { extends as _extends } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useState, useRef, useCallback } from 'react';
+import { ENTERED, startOrEnd, getEndState, PRE_EXIT, EXITING, PRE_ENTER, ENTERING, getFullState, getTimeout } from './utils.js';
+
+var initialStateMap = new Map();
+var initialConfigMap = new Map();
+
+var updateState = function updateState(_ref) {
+  var key = _ref.key,
+      _state = _ref.newState,
+      setStateMap = _ref.setStateMap,
+      latestStateMap = _ref.latestStateMap,
+      timeoutId = _ref.timeoutId,
+      onChange = _ref.onChange;
+  clearTimeout(timeoutId);
+  var state = getFullState(_state);
+  var stateMap = new Map(latestStateMap.current);
+  stateMap.set(key, state);
+  setStateMap(stateMap);
+  latestStateMap.current = stateMap;
+  onChange && onChange(_extends({
+    key: key
+  }, state));
+};
+
+var useTransitionMap = function useTransitionMap(_temp) {
+  var _ref2 = _temp === void 0 ? {} : _temp,
+      singleEnter = _ref2.singleEnter;
+
+  var _useState = useState(initialStateMap),
+      stateMap = _useState[0],
+      setStateMap = _useState[1];
+
+  var latestStateMap = useRef(stateMap);
+  var configMap = useRef(initialConfigMap);
+  var setItem = useCallback(function (key, config) {
+    if (config === void 0) {
+      config = {};
+    }
+
+    var _config = config,
+        initialEntered = _config.initialEntered,
+        mountOnEnter = _config.mountOnEnter;
+    var newState = initialEntered ? ENTERED : startOrEnd(mountOnEnter);
+    updateState({
+      key: key,
+      newState: newState,
+      setStateMap: setStateMap,
+      latestStateMap: latestStateMap
+    });
+    configMap.current.set(key, _extends({}, config));
+  }, []);
+  var deleteItem = useCallback(function (key) {
+    var newStateMap = new Map(latestStateMap.current);
+
+    if (newStateMap.delete(key)) {
+      setStateMap(newStateMap);
+      latestStateMap.current = newStateMap;
+      configMap.current.delete(key);
+      return true;
+    }
+
+    return false;
+  }, []);
+  var endTransition = useCallback(function (key) {
+    var stateObj = latestStateMap.current.get(key);
+
+    if (!stateObj) {
+      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid key: " + key);
+      return;
+    }
+
+    var _configMap$current$ge = configMap.current.get(key),
+        timeoutId = _configMap$current$ge.timeoutId,
+        onChange = _configMap$current$ge.onChange,
+        unmountOnExit = _configMap$current$ge.unmountOnExit;
+
+    var newState = getEndState(stateObj._state, unmountOnExit);
+    newState && updateState({
+      key: key,
+      newState: newState,
+      setStateMap: setStateMap,
+      latestStateMap: latestStateMap,
+      timeoutId: timeoutId,
+      onChange: onChange
+    });
+  }, []);
+  var toggle = useCallback(function (key, toEnter) {
+    var stateObj = latestStateMap.current.get(key);
+
+    if (!stateObj) {
+      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid key: " + key);
+      return;
+    }
+
+    var config = configMap.current.get(key);
+    var _config$enter = config.enter,
+        enter = _config$enter === void 0 ? true : _config$enter,
+        _config$exit = config.exit,
+        exit = _config$exit === void 0 ? true : _config$exit,
+        preEnter = config.preEnter,
+        preExit = config.preExit,
+        timeout = config.timeout,
+        unmountOnExit = config.unmountOnExit,
+        onChange = config.onChange,
+        timeoutId = config.timeoutId;
+
+    var transitState = function transitState(newState) {
+      updateState({
+        key: key,
+        newState: newState,
+        setStateMap: setStateMap,
+        latestStateMap: latestStateMap,
+        timeoutId: timeoutId,
+        onChange: onChange
+      });
+
+      var _getTimeout = getTimeout(timeout),
+          enterTimeout = _getTimeout[0],
+          exitTimeout = _getTimeout[1];
+
+      switch (newState) {
+        case ENTERING:
+          if (enterTimeout >= 0) config.timeoutId = setTimeout(function () {
+            return endTransition(key);
+          }, enterTimeout);
+          break;
+
+        case EXITING:
+          if (exitTimeout >= 0) config.timeoutId = setTimeout(function () {
+            return endTransition(key);
+          }, exitTimeout);
+          break;
+
+        case PRE_ENTER:
+        case PRE_EXIT:
+          config.timeoutId = setTimeout(function () {
+            return transitState(newState + 1);
+          }, 0);
+          break;
+      }
+    };
+
+    var enterStage = stateObj._state <= ENTERED;
+    if (typeof toEnter !== 'boolean') toEnter = !enterStage;
+
+    if (toEnter) {
+      if (!enterStage) {
+        transitState(enter ? preEnter ? PRE_ENTER : ENTERING : ENTERED);
+        singleEnter && latestStateMap.current.forEach(function (_, _key) {
+          return _key !== key && toggle(_key, false);
+        });
+      }
+    } else {
+      if (enterStage) {
+        transitState(exit ? preExit ? PRE_EXIT : EXITING : startOrEnd(unmountOnExit));
+      }
+    }
+  }, [endTransition, singleEnter]);
+  return {
+    stateMap: stateMap,
+    toggle: toggle,
+    endTransition: endTransition,
+    setItem: setItem,
+    deleteItem: deleteItem
+  };
+};
+
+export { useTransitionMap };

package/dist/es/hooks/utils.js

@@ -0,0 +1,35 @@
+var PRE_ENTER = 0;
+var ENTERING = 1;
+var ENTERED = 2;
+var PRE_EXIT = 3;
+var EXITING = 4;
+var EXITED = 5;
+var UNMOUNTED = 6;
+var STATES = ['preEnter', 'entering', 'entered', 'preExit', 'exiting', 'exited', 'unmounted'];
+var getFullState = function getFullState(_state) {
+  return {
+    _state: _state,
+    state: STATES[_state],
+    isEnter: _state < PRE_EXIT,
+    isMounted: _state !== UNMOUNTED
+  };
+};
+var startOrEnd = function startOrEnd(unmounted) {
+  return unmounted ? UNMOUNTED : EXITED;
+};
+var getEndState = function getEndState(state, unmountOnExit) {
+  switch (state) {
+    case ENTERING:
+    case PRE_ENTER:
+      return ENTERED;
+
+    case EXITING:
+    case PRE_EXIT:
+      return startOrEnd(unmountOnExit);
+  }
+};
+var getTimeout = function getTimeout(timeout) {
+  return typeof timeout === 'object' ? [timeout.enter, timeout.exit] : [timeout, timeout];
+};
+
+export { ENTERED, ENTERING, EXITED, EXITING, PRE_ENTER, PRE_EXIT, STATES, UNMOUNTED, getEndState, getFullState, getTimeout, startOrEnd };

package/dist/es/index.js

@@ -0,0 +1,2 @@
+export { useTransition as default, useTransition } from './hooks/useTransition.js';
+export { useTransitionMap } from './hooks/useTransitionMap.js';

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "react-transition-state",
-  "version": "1.2.0-alpha.0",
+  "version": "1.2.0-alpha.3",
   "description": "Zero dependency, 0.7KB react-transition-group alternative.",
   "author": "Zheng Song",
   "license": "MIT",
   "repository": "szhsin/react-transition-state",
   "homepage": "https://szhsin.github.io/react-transition-state/",
-  "main": "dist/index.js",
-  "module": "dist/index.es.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/es/index.js",
+  "types": "types/index.d.ts",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist/",
+    "types/*.d.ts"
   ],
   "keywords": [
     "react",
@@ -26,12 +27,12 @@
     "bundle": "rollup -c",
     "test": "jest",
     "eg": "npm start --prefix example",
-    "dtslint": "dtslint --localTs node_modules/typescript/lib types",
-    "types": "npm run dtslint && cp -f types/index.d.ts dist/",
+    "types": "dtslint --localTs node_modules/typescript/lib types",
     "tsc": "cd types && tsc",
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
-    "pret": "prettier --write .",
+    "pret": "prettier -c .",
+    "pret:fix": "prettier -w .",
     "build": "run-s clean lint pret bundle types"
   },
   "peerDependencies": {

package/types/index.d.ts

@@ -0,0 +1,50 @@
+export type TransitionState =
+  | 'preEnter'
+  | 'entering'
+  | 'entered'
+  | 'preExit'
+  | 'exiting'
+  | 'exited'
+  | 'unmounted';
+
+export interface State {
+  state: TransitionState;
+  isMounted: boolean;
+  isEnter: boolean;
+}
+
+export interface TransitionOptions {
+  initialEntered?: boolean;
+  mountOnEnter?: boolean;
+  unmountOnExit?: boolean;
+  preEnter?: boolean;
+  preExit?: boolean;
+  enter?: boolean;
+  exit?: boolean;
+  timeout?: number | { enter?: number; exit?: number };
+  onChange?: (event: { state: TransitionState }) => void;
+}
+
+export interface TransitionItemOptions<K> extends Omit<TransitionOptions, 'onChange'> {
+  onChange?: (event: { key: K } & State) => void;
+}
+
+export interface TransitionMapOptions {
+  singleEnter?: boolean;
+}
+
+export type TransitionResult = [TransitionState, (toEnter?: boolean) => void, () => void];
+
+export interface TransitionMapResult<K> {
+  stateMap: Omit<Map<K, State>, 'clear' | 'delete' | 'set'>;
+  toggle: (key: K, toEnter?: boolean) => void;
+  endTransition: (key: K) => void;
+  setItem: (key: K, options?: TransitionItemOptions<K>) => void;
+  deleteItem: (key: K) => boolean;
+}
+
+export const useTransition: (options?: TransitionOptions) => TransitionResult;
+
+export const useTransitionMap: <K>(options?: TransitionMapOptions) => TransitionMapResult<K>;
+
+export default useTransition;

package/dist/index.d.ts

@@ -1,26 +0,0 @@
-export type TransitionState =
-  | 'preEnter'
-  | 'entering'
-  | 'entered'
-  | 'preExit'
-  | 'exiting'
-  | 'exited'
-  | 'unmounted';
-
-export interface TransitionOptions {
-  initialEntered?: boolean;
-  mountOnEnter?: boolean;
-  unmountOnExit?: boolean;
-  preEnter?: boolean;
-  preExit?: boolean;
-  enter?: boolean;
-  exit?: boolean;
-  timeout?: number | { enter?: number; exit?: number };
-  onChange?: (event: { state: TransitionState }) => void;
-}
-
-export const useTransition: (
-  options?: TransitionOptions
-) => [TransitionState, (toEnter?: boolean) => void, () => void];
-
-export default useTransition;

package/dist/index.es.js

@@ -1,261 +0,0 @@
-import { useState, useRef, useCallback, useEffect } from 'react';
-
-var PRE_ENTER = 0;
-var ENTERING = 1;
-var ENTERED = 2;
-var PRE_EXIT = 3;
-var EXITING = 4;
-var EXITED = 5;
-var UNMOUNTED = 6;
-var STATES = ['preEnter', 'entering', 'entered', 'preExit', 'exiting', 'exited', 'unmounted'];
-var startOrEnd = function startOrEnd(unmounted) {
-  return unmounted ? UNMOUNTED : EXITED;
-};
-var getEndState = function getEndState(state, unmountOnExit) {
-  switch (state) {
-    case ENTERING:
-    case PRE_ENTER:
-      return ENTERED;
-
-    case EXITING:
-    case PRE_EXIT:
-      return startOrEnd(unmountOnExit);
-  }
-};
-var getTimeout = function getTimeout(timeout) {
-  return typeof timeout === 'object' ? [timeout.enter, timeout.exit] : [timeout, timeout];
-};
-
-var updateState$1 = function updateState(state, setState, latestState, timeoutId, onChange) {
-  clearTimeout(timeoutId.current);
-  setState(state);
-  latestState.current = state;
-  onChange && onChange({
-    state: STATES[state]
-  });
-};
-
-var useTransition = function useTransition(_temp) {
-  var _ref = _temp === void 0 ? {} : _temp,
-      _ref$enter = _ref.enter,
-      enter = _ref$enter === void 0 ? true : _ref$enter,
-      _ref$exit = _ref.exit,
-      exit = _ref$exit === void 0 ? true : _ref$exit,
-      preEnter = _ref.preEnter,
-      preExit = _ref.preExit,
-      timeout = _ref.timeout,
-      initialEntered = _ref.initialEntered,
-      mountOnEnter = _ref.mountOnEnter,
-      unmountOnExit = _ref.unmountOnExit,
-      onChange = _ref.onChange;
-
-  var _useState = useState(initialEntered ? ENTERED : startOrEnd(mountOnEnter)),
-      state = _useState[0],
-      setState = _useState[1];
-
-  var latestState = useRef(state);
-  var timeoutId = useRef();
-
-  var _getTimeout = getTimeout(timeout),
-      enterTimeout = _getTimeout[0],
-      exitTimeout = _getTimeout[1];
-
-  var endTransition = useCallback(function () {
-    var newState = getEndState(latestState.current, unmountOnExit);
-    newState && updateState$1(newState, setState, latestState, timeoutId, onChange);
-  }, [onChange, unmountOnExit]);
-  var toggle = useCallback(function (toEnter) {
-    var transitState = function transitState(newState) {
-      updateState$1(newState, setState, latestState, timeoutId, onChange);
-
-      switch (newState) {
-        case ENTERING:
-          if (enterTimeout >= 0) timeoutId.current = setTimeout(endTransition, enterTimeout);
-          break;
-
-        case EXITING:
-          if (exitTimeout >= 0) timeoutId.current = setTimeout(endTransition, exitTimeout);
-          break;
-
-        case PRE_ENTER:
-        case PRE_EXIT:
-          timeoutId.current = setTimeout(function () {
-            return transitState(newState + 1);
-          }, 0);
-          break;
-      }
-    };
-
-    var enterStage = latestState.current <= ENTERED;
-    if (typeof toEnter !== 'boolean') toEnter = !enterStage;
-
-    if (toEnter) {
-      if (!enterStage) {
-        transitState(enter ? preEnter ? PRE_ENTER : ENTERING : ENTERED);
-      }
-    } else {
-      if (enterStage) {
-        transitState(exit ? preExit ? PRE_EXIT : EXITING : startOrEnd(unmountOnExit));
-      }
-    }
-  }, [endTransition, onChange, enter, exit, preEnter, preExit, enterTimeout, exitTimeout, unmountOnExit]);
-  useEffect(function () {
-    return function () {
-      return clearTimeout(timeoutId.current);
-    };
-  }, []);
-  return [STATES[state], toggle, endTransition];
-};
-
-var initialStateMap = new Map();
-var initialConfigMap = new Map();
-
-var updateState = function updateState(_ref) {
-  var item = _ref.item,
-      _state = _ref.newState,
-      setStateMap = _ref.setStateMap,
-      latestStateMap = _ref.latestStateMap,
-      timeoutId = _ref.timeoutId,
-      onChange = _ref.onChange;
-  clearTimeout(timeoutId);
-  var state = {
-    state: STATES[_state],
-    _state: _state
-  };
-  var stateMap = new Map(latestStateMap.current);
-  stateMap.set(item, state);
-  setStateMap(stateMap);
-  latestStateMap.current = stateMap;
-  onChange && onChange(item, state);
-};
-
-var useTransitionMap = function useTransitionMap() {
-  var _useState = useState(initialStateMap),
-      stateMap = _useState[0],
-      setStateMap = _useState[1];
-
-  var latestStateMap = useRef(stateMap);
-  var configMap = useRef(initialConfigMap);
-  var addItem = useCallback(function (item, config) {
-    var initialEntered = config.initialEntered,
-        mountOnEnter = config.mountOnEnter;
-    var newState = initialEntered ? ENTERED : startOrEnd(mountOnEnter);
-    updateState({
-      item: item,
-      newState: newState,
-      setStateMap: setStateMap,
-      latestStateMap: latestStateMap
-    });
-    configMap.current.set(item, config);
-  }, []);
-  var removeItem = useCallback(function (item) {
-    var newStateMap = new Map(latestStateMap.current);
-
-    if (newStateMap.delete(item)) {
-      setStateMap(newStateMap);
-      latestStateMap.current = newStateMap;
-      configMap.current.delete(item);
-    }
-  }, []);
-  var endTransition = useCallback(function (item) {
-    var stateObj = latestStateMap.current.get(item);
-
-    if (!stateObj) {
-      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid item key for " + item);
-      return;
-    }
-
-    var _configMap$current$ge = configMap.current.get(item),
-        timeoutId = _configMap$current$ge.timeoutId,
-        onChange = _configMap$current$ge.onChange,
-        unmountOnExit = _configMap$current$ge.unmountOnExit;
-
-    var newState = getEndState(stateObj._state, unmountOnExit);
-    newState && updateState({
-      item: item,
-      newState: newState,
-      setStateMap: setStateMap,
-      latestStateMap: latestStateMap,
-      timeoutId: timeoutId,
-      onChange: onChange
-    });
-  }, []);
-  var toggle = useCallback(function (item, toEnter) {
-    var stateObj = latestStateMap.current.get(item);
-
-    if (!stateObj) {
-      process.env.NODE_ENV !== 'production' && console.error("[React-Transition-State] invalid item key for " + item);
-      return;
-    }
-
-    var config = configMap.current.get(item);
-    var _config$enter = config.enter,
-        enter = _config$enter === void 0 ? true : _config$enter,
-        _config$exit = config.exit,
-        exit = _config$exit === void 0 ? true : _config$exit,
-        preEnter = config.preEnter,
-        preExit = config.preExit,
-        timeout = config.timeout,
-        unmountOnExit = config.unmountOnExit,
-        onChange = config.onChange,
-        timeoutId = config.timeoutId;
-
-    var transitState = function transitState(newState) {
-      updateState({
-        item: item,
-        newState: newState,
-        setStateMap: setStateMap,
-        latestStateMap: latestStateMap,
-        timeoutId: timeoutId,
-        onChange: onChange
-      });
-
-      var _getTimeout = getTimeout(timeout),
-          enterTimeout = _getTimeout[0],
-          exitTimeout = _getTimeout[1];
-
-      switch (newState) {
-        case ENTERING:
-          if (enterTimeout >= 0) config.timeoutId = setTimeout(function () {
-            return endTransition(item);
-          }, enterTimeout);
-          break;
-
-        case EXITING:
-          if (exitTimeout >= 0) config.timeoutId = setTimeout(function () {
-            return endTransition(item);
-          }, exitTimeout);
-          break;
-
-        case PRE_ENTER:
-        case PRE_EXIT:
-          config.timeoutId = setTimeout(function () {
-            return transitState(newState + 1);
-          }, 0);
-          break;
-      }
-    };
-
-    var enterStage = stateObj._state <= ENTERED;
-    if (typeof toEnter !== 'boolean') toEnter = !enterStage;
-
-    if (toEnter) {
-      if (!enterStage) {
-        transitState(enter ? preEnter ? PRE_ENTER : ENTERING : ENTERED);
-      }
-    } else {
-      if (enterStage) {
-        transitState(exit ? preExit ? PRE_EXIT : EXITING : startOrEnd(unmountOnExit));
-      }
-    }
-  }, [endTransition]);
-  return {
-    stateMap: stateMap,
-    toggle: toggle,
-    endTransition: endTransition,
-    addItem: addItem,
-    removeItem: removeItem
-  };
-};
-
-export { useTransition as default, useTransition, useTransitionMap };