From 17fd5a7303f88abe7cc8d38d083d0ce95a9110ae Mon Sep 17 00:00:00 2001 From: Maxime Renou Date: Fri, 1 Mar 2019 12:22:51 +0100 Subject: [PATCH] Youhou --- .babelrc | 9 + .editorconfig | 9 + .eslintrc | 23 + .gitignore | 4 + .travis.yml | 4 + README.md | 31 + dist/index.es.js | 3276 ++++++++++++++++++ dist/index.es.js.map | 1 + dist/index.js | 3291 ++++++++++++++++++ dist/index.js.map | 1 + package.json | 64 + rollup.config.js | 39 + src/.eslintrc | 5 + src/CheckBox.js | 49 + src/Form.js | 71 + src/FormContext.js | 17 + src/FormItemError.js | 14 + src/Input.js | 46 + src/Option.js | 27 + src/OptionGroup.js | 83 + src/Radio.js | 48 + src/RadioGroup.js | 66 + src/Submit.js | 13 + src/TextArea.js | 44 + src/index.js | 13 + yarn.lock | 9092 ++++++++++++++++++++++++++++++++++++++++++++++++++ 26 files changed, 16340 insertions(+) create mode 100644 .babelrc create mode 100644 .editorconfig create mode 100644 .eslintrc create mode 100644 .gitignore create mode 100644 .travis.yml create mode 100644 README.md create mode 100644 dist/index.es.js create mode 100644 dist/index.es.js.map create mode 100644 dist/index.js create mode 100644 dist/index.js.map create mode 100644 package.json create mode 100644 rollup.config.js create mode 100644 src/.eslintrc create mode 100644 src/CheckBox.js create mode 100644 src/Form.js create mode 100644 src/FormContext.js create mode 100644 src/FormItemError.js create mode 100644 src/Input.js create mode 100644 src/Option.js create mode 100644 src/OptionGroup.js create mode 100644 src/Radio.js create mode 100644 src/RadioGroup.js create mode 100644 src/Submit.js create mode 100644 src/TextArea.js create mode 100644 src/index.js create mode 100644 yarn.lock diff --git a/.babelrc b/.babelrc new file mode 100644 index 0000000..723ea64 --- /dev/null +++ b/.babelrc @@ -0,0 +1,9 @@ +{ + "presets": [ + ["env", { + "modules": false + }], + "stage-0", + "react" + ] +} diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..9d08a1a --- /dev/null +++ b/.editorconfig @@ -0,0 +1,9 @@ +root = true + +[*] +charset = utf-8 +indent_style = space +indent_size = 2 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true diff --git a/.eslintrc b/.eslintrc new file mode 100644 index 0000000..e74d212 --- /dev/null +++ b/.eslintrc @@ -0,0 +1,23 @@ +{ + "parser": "babel-eslint", + "extends": [ + "standard", + "standard-react" + ], + "env": { + "es6": true + }, + "plugins": [ + "react" + ], + "parserOptions": { + "sourceType": "module" + }, + "rules": { + // don't force es6 functions to include space before paren + "space-before-function-paren": 0, + + // allow specifying true explicitly for boolean props + "react/jsx-boolean-value": 0 + } +} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9d17427 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.DS_Store +node_modules/ +.idea/ +example/ \ No newline at end of file diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..984658c --- /dev/null +++ b/.travis.yml @@ -0,0 +1,4 @@ +language: node_js +node_js: + - 9 + - 8 diff --git a/README.md b/README.md new file mode 100644 index 0000000..bfa34f2 --- /dev/null +++ b/README.md @@ -0,0 +1,31 @@ +# react-forms + +> React form components + +[![NPM](https://img.shields.io/npm/v/react-forms.svg)](https://www.npmjs.com/package/react-forms) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com) + +## Install + +```bash +npm install --save react-forms +``` + +## Usage + +```jsx +import React, { Component } from 'react' + +import MyComponent from 'react-forms' + +class Example extends Component { + render () { + return ( + + ) + } +} +``` + +## License + +MIT © [maximerenou](https://github.com/maximerenou) diff --git a/dist/index.es.js b/dist/index.es.js new file mode 100644 index 0000000..792ef9f --- /dev/null +++ b/dist/index.es.js @@ -0,0 +1,3276 @@ +import React, { Component } from 'react'; +import require$$0 from 'prop-types'; +import reactDom from 'react-dom'; + +var classCallCheck = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +}; + +var createClass = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; +}(); + +var _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; +}; + +var inherits = function (subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + enumerable: false, + writable: true, + configurable: true + } + }); + if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; +}; + +var possibleConstructorReturn = function (self, call) { + if (!self) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return call && (typeof call === "object" || typeof call === "function") ? call : self; +}; + +var FormContext = React.createContext({ data: null }); + +var FormConsumer = function (_Component) { + inherits(FormConsumer, _Component); + + function FormConsumer() { + classCallCheck(this, FormConsumer); + return possibleConstructorReturn(this, (FormConsumer.__proto__ || Object.getPrototypeOf(FormConsumer)).apply(this, arguments)); + } + + createClass(FormConsumer, [{ + key: 'render', + value: function render() { + var _this2 = this; + + return React.createElement( + FormContext.Consumer, + null, + function (props) { + return _this2.props.children(props); + } + ); + } + }]); + return FormConsumer; +}(Component); + +var FormItemError = function (_Component) { + inherits(FormItemError, _Component); + + function FormItemError() { + classCallCheck(this, FormItemError); + return possibleConstructorReturn(this, (FormItemError.__proto__ || Object.getPrototypeOf(FormItemError)).apply(this, arguments)); + } + + createClass(FormItemError, [{ + key: "render", + value: function render() { + var data = this.props.data; + + if (!data || !data.errors || !data.errors[this.props.name]) return null; + + return React.createElement( + "p", + { className: "text-danger" }, + data.errors[this.props.name].error + ); + } + }]); + return FormItemError; +}(Component); + +var CheckBox = function (_Component) { + inherits(CheckBox, _Component); + + function CheckBox() { + classCallCheck(this, CheckBox); + return possibleConstructorReturn(this, (CheckBox.__proto__ || Object.getPrototypeOf(CheckBox)).apply(this, arguments)); + } + + createClass(CheckBox, [{ + key: "render", + value: function render() { + var _this2 = this; + + return React.createElement( + FormConsumer, + null, + function (data) { + return _this2.renderCheckBox(data); + } + ); + } + }, { + key: "renderCheckBox", + value: function renderCheckBox(data) { + var _this3 = this; + + var props = _extends({}, this.props); + if (props.children) delete props.children; + if (props.onChangeValue) delete props.onChangeValue; + return React.createElement( + "div", + { className: "form-check" }, + React.createElement("input", _extends({ + type: "checkbox", + checked: this.props.value, + onChange: function onChange(e) { + return _this3.props.onChangeValue(e.target.checked); + } + }, props)), + this.renderLabel(data), + React.createElement(FormItemError, { name: this.props.name, data: data }) + ); + } + }, { + key: "renderLabel", + value: function renderLabel(data) { + if (this.props.children.length) { + return React.createElement( + "label", + { className: "form-check-label", htmlFor: this.props.id }, + this.props.children + ); + } + } + }]); + return CheckBox; +}(Component); + + +CheckBox.defaultProps = { + name: 'checkbox', + id: 'checkbox', + className: 'form-check-input', + onChangeValue: function onChangeValue(checked) {} +}; + +function unwrapExports (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x.default : x; +} + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var classnames = createCommonjsModule(function (module) { +/*! + Copyright (c) 2017 Jed Watson. + Licensed under the MIT License (MIT), see + http://jedwatson.github.io/classnames +*/ +/* global define */ + +(function () { + + var hasOwn = {}.hasOwnProperty; + + function classNames () { + var classes = []; + + for (var i = 0; i < arguments.length; i++) { + var arg = arguments[i]; + if (!arg) continue; + + var argType = typeof arg; + + if (argType === 'string' || argType === 'number') { + classes.push(arg); + } else if (Array.isArray(arg) && arg.length) { + var inner = classNames.apply(null, arg); + if (inner) { + classes.push(inner); + } + } else if (argType === 'object') { + for (var key in arg) { + if (hasOwn.call(arg, key) && arg[key]) { + classes.push(key); + } + } + } + } + + return classes.join(' '); + } + + if (module.exports) { + classNames.default = classNames; + module.exports = classNames; + } else { + window.classNames = classNames; + } +}()); +}); + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +function componentWillMount() { + // Call this.constructor.gDSFP to support sub-classes. + var state = this.constructor.getDerivedStateFromProps(this.props, this.state); + if (state !== null && state !== undefined) { + this.setState(state); + } +} + +function componentWillReceiveProps(nextProps) { + // Call this.constructor.gDSFP to support sub-classes. + // Use the setState() updater to ensure state isn't stale in certain edge cases. + function updater(prevState) { + var state = this.constructor.getDerivedStateFromProps(nextProps, prevState); + return state !== null && state !== undefined ? state : null; + } + // Binding "this" is important for shallow renderer support. + this.setState(updater.bind(this)); +} + +function componentWillUpdate(nextProps, nextState) { + try { + var prevProps = this.props; + var prevState = this.state; + this.props = nextProps; + this.state = nextState; + this.__reactInternalSnapshotFlag = true; + this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate( + prevProps, + prevState + ); + } finally { + this.props = prevProps; + this.state = prevState; + } +} + +// React may warn about cWM/cWRP/cWU methods being deprecated. +// Add a flag to suppress these warnings for this special case. +componentWillMount.__suppressDeprecationWarning = true; +componentWillReceiveProps.__suppressDeprecationWarning = true; +componentWillUpdate.__suppressDeprecationWarning = true; + +function polyfill(Component$$1) { + var prototype = Component$$1.prototype; + + if (!prototype || !prototype.isReactComponent) { + throw new Error('Can only polyfill class components'); + } + + if ( + typeof Component$$1.getDerivedStateFromProps !== 'function' && + typeof prototype.getSnapshotBeforeUpdate !== 'function' + ) { + return Component$$1; + } + + // If new component APIs are defined, "unsafe" lifecycles won't be called. + // Error if any of these lifecycles are present, + // Because they would work differently between older and newer (16.3+) versions of React. + var foundWillMountName = null; + var foundWillReceivePropsName = null; + var foundWillUpdateName = null; + if (typeof prototype.componentWillMount === 'function') { + foundWillMountName = 'componentWillMount'; + } else if (typeof prototype.UNSAFE_componentWillMount === 'function') { + foundWillMountName = 'UNSAFE_componentWillMount'; + } + if (typeof prototype.componentWillReceiveProps === 'function') { + foundWillReceivePropsName = 'componentWillReceiveProps'; + } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') { + foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps'; + } + if (typeof prototype.componentWillUpdate === 'function') { + foundWillUpdateName = 'componentWillUpdate'; + } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') { + foundWillUpdateName = 'UNSAFE_componentWillUpdate'; + } + if ( + foundWillMountName !== null || + foundWillReceivePropsName !== null || + foundWillUpdateName !== null + ) { + var componentName = Component$$1.displayName || Component$$1.name; + var newApiName = + typeof Component$$1.getDerivedStateFromProps === 'function' + ? 'getDerivedStateFromProps()' + : 'getSnapshotBeforeUpdate()'; + + throw Error( + 'Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' + + componentName + + ' uses ' + + newApiName + + ' but also contains the following legacy lifecycles:' + + (foundWillMountName !== null ? '\n ' + foundWillMountName : '') + + (foundWillReceivePropsName !== null + ? '\n ' + foundWillReceivePropsName + : '') + + (foundWillUpdateName !== null ? '\n ' + foundWillUpdateName : '') + + '\n\nThe above lifecycles should be removed. Learn more about this warning here:\n' + + 'https://fb.me/react-async-component-lifecycle-hooks' + ); + } + + // React <= 16.2 does not support static getDerivedStateFromProps. + // As a workaround, use cWM and cWRP to invoke the new static lifecycle. + // Newer versions of React will ignore these lifecycles if gDSFP exists. + if (typeof Component$$1.getDerivedStateFromProps === 'function') { + prototype.componentWillMount = componentWillMount; + prototype.componentWillReceiveProps = componentWillReceiveProps; + } + + // React <= 16.2 does not support getSnapshotBeforeUpdate. + // As a workaround, use cWU to invoke the new lifecycle. + // Newer versions of React will ignore that lifecycle if gSBU exists. + if (typeof prototype.getSnapshotBeforeUpdate === 'function') { + if (typeof prototype.componentDidUpdate !== 'function') { + throw new Error( + 'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype' + ); + } + + prototype.componentWillUpdate = componentWillUpdate; + + var componentDidUpdate = prototype.componentDidUpdate; + + prototype.componentDidUpdate = function componentDidUpdatePolyfill( + prevProps, + prevState, + maybeSnapshot + ) { + // 16.3+ will not execute our will-update method; + // It will pass a snapshot value to did-update though. + // Older versions will require our polyfilled will-update value. + // We need to handle both cases, but can't just check for the presence of "maybeSnapshot", + // Because for <= 15.x versions this might be a "prevContext" object. + // We also can't just check "__reactInternalSnapshot", + // Because get-snapshot might return a falsy value. + // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior. + var snapshot = this.__reactInternalSnapshotFlag + ? this.__reactInternalSnapshot + : maybeSnapshot; + + componentDidUpdate.call(this, prevProps, prevState, snapshot); + }; + } + + return Component$$1; +} + +var reactLifecyclesCompat_es = /*#__PURE__*/Object.freeze({ + polyfill: polyfill +}); + +var ChildMapping = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.getChildMapping = getChildMapping; +exports.mergeChildMappings = mergeChildMappings; +exports.getInitialChildMapping = getInitialChildMapping; +exports.getNextChildMapping = getNextChildMapping; + + + +/** + * Given `this.props.children`, return an object mapping key to child. + * + * @param {*} children `this.props.children` + * @return {object} Mapping of key to child + */ +function getChildMapping(children, mapFn) { + var mapper = function mapper(child) { + return mapFn && (0, React.isValidElement)(child) ? mapFn(child) : child; + }; + + var result = Object.create(null); + if (children) React.Children.map(children, function (c) { + return c; + }).forEach(function (child) { + // run the map function here instead so that the key is the computed one + result[child.key] = mapper(child); + }); + return result; +} +/** + * When you're adding or removing children some may be added or removed in the + * same render pass. We want to show *both* since we want to simultaneously + * animate elements in and out. This function takes a previous set of keys + * and a new set of keys and merges them with its best guess of the correct + * ordering. In the future we may expose some of the utilities in + * ReactMultiChild to make this easy, but for now React itself does not + * directly have this concept of the union of prevChildren and nextChildren + * so we implement it here. + * + * @param {object} prev prev children as returned from + * `ReactTransitionChildMapping.getChildMapping()`. + * @param {object} next next children as returned from + * `ReactTransitionChildMapping.getChildMapping()`. + * @return {object} a key set that contains all keys in `prev` and all keys + * in `next` in a reasonable order. + */ + + +function mergeChildMappings(prev, next) { + prev = prev || {}; + next = next || {}; + + function getValueForKey(key) { + return key in next ? next[key] : prev[key]; + } // For each key of `next`, the list of keys to insert before that key in + // the combined list + + + var nextKeysPending = Object.create(null); + var pendingKeys = []; + + for (var prevKey in prev) { + if (prevKey in next) { + if (pendingKeys.length) { + nextKeysPending[prevKey] = pendingKeys; + pendingKeys = []; + } + } else { + pendingKeys.push(prevKey); + } + } + + var i; + var childMapping = {}; + + for (var nextKey in next) { + if (nextKeysPending[nextKey]) { + for (i = 0; i < nextKeysPending[nextKey].length; i++) { + var pendingNextKey = nextKeysPending[nextKey][i]; + childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey); + } + } + + childMapping[nextKey] = getValueForKey(nextKey); + } // Finally, add the keys which didn't appear before any key in `next` + + + for (i = 0; i < pendingKeys.length; i++) { + childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]); + } + + return childMapping; +} + +function getProp(child, prop, props) { + return props[prop] != null ? props[prop] : child.props[prop]; +} + +function getInitialChildMapping(props, onExited) { + return getChildMapping(props.children, function (child) { + return (0, React.cloneElement)(child, { + onExited: onExited.bind(null, child), + in: true, + appear: getProp(child, 'appear', props), + enter: getProp(child, 'enter', props), + exit: getProp(child, 'exit', props) + }); + }); +} + +function getNextChildMapping(nextProps, prevChildMapping, onExited) { + var nextChildMapping = getChildMapping(nextProps.children); + var children = mergeChildMappings(prevChildMapping, nextChildMapping); + Object.keys(children).forEach(function (key) { + var child = children[key]; + if (!(0, React.isValidElement)(child)) return; + var hasPrev = key in prevChildMapping; + var hasNext = key in nextChildMapping; + var prevChild = prevChildMapping[key]; + var isLeaving = (0, React.isValidElement)(prevChild) && !prevChild.props.in; // item is new (entering) + + if (hasNext && (!hasPrev || isLeaving)) { + // console.log('entering', key) + children[key] = (0, React.cloneElement)(child, { + onExited: onExited.bind(null, child), + in: true, + exit: getProp(child, 'exit', nextProps), + enter: getProp(child, 'enter', nextProps) + }); + } else if (!hasNext && hasPrev && !isLeaving) { + // item is old (exiting) + // console.log('leaving', key) + children[key] = (0, React.cloneElement)(child, { + in: false + }); + } else if (hasNext && hasPrev && (0, React.isValidElement)(prevChild)) { + // item hasn't changed transition states + // copy over the last transition props; + // console.log('unchanged', key) + children[key] = (0, React.cloneElement)(child, { + onExited: onExited.bind(null, child), + in: prevChild.props.in, + exit: getProp(child, 'exit', nextProps), + enter: getProp(child, 'enter', nextProps) + }); + } + }); + return children; +} +}); + +unwrapExports(ChildMapping); +var ChildMapping_1 = ChildMapping.getChildMapping; +var ChildMapping_2 = ChildMapping.mergeChildMappings; +var ChildMapping_3 = ChildMapping.getInitialChildMapping; +var ChildMapping_4 = ChildMapping.getNextChildMapping; + +var TransitionGroup_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; + +var _propTypes = _interopRequireDefault(require$$0); + +var _react = _interopRequireDefault(React); + + + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +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; } + +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); } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +var values = Object.values || function (obj) { + return Object.keys(obj).map(function (k) { + return obj[k]; + }); +}; + +var defaultProps = { + component: 'div', + childFactory: function childFactory(child) { + return child; + } + /** + * The `` component manages a set of transition components + * (`` and ``) in a list. Like with the transition + * components, `` is a state machine for managing the mounting + * and unmounting of components over time. + * + * Consider the example below. As items are removed or added to the TodoList the + * `in` prop is toggled automatically by the ``. + * + * Note that `` does not define any animation behavior! + * Exactly _how_ a list item animates is up to the individual transition + * component. This means you can mix and match animations across different list + * items. + */ + +}; + +var TransitionGroup = +/*#__PURE__*/ +function (_React$Component) { + _inheritsLoose(TransitionGroup, _React$Component); + + function TransitionGroup(props, context) { + var _this; + + _this = _React$Component.call(this, props, context) || this; + + var handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this))); // Initial children should all be entering, dependent on appear + + + _this.state = { + handleExited: handleExited, + firstRender: true + }; + return _this; + } + + var _proto = TransitionGroup.prototype; + + _proto.getChildContext = function getChildContext() { + return { + transitionGroup: { + isMounting: !this.appeared + } + }; + }; + + _proto.componentDidMount = function componentDidMount() { + this.appeared = true; + this.mounted = true; + }; + + _proto.componentWillUnmount = function componentWillUnmount() { + this.mounted = false; + }; + + TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) { + var prevChildMapping = _ref.children, + handleExited = _ref.handleExited, + firstRender = _ref.firstRender; + return { + children: firstRender ? (0, ChildMapping.getInitialChildMapping)(nextProps, handleExited) : (0, ChildMapping.getNextChildMapping)(nextProps, prevChildMapping, handleExited), + firstRender: false + }; + }; + + _proto.handleExited = function handleExited(child, node) { + var currentChildMapping = (0, ChildMapping.getChildMapping)(this.props.children); + if (child.key in currentChildMapping) return; + + if (child.props.onExited) { + child.props.onExited(node); + } + + if (this.mounted) { + this.setState(function (state) { + var children = _extends({}, state.children); + + delete children[child.key]; + return { + children: children + }; + }); + } + }; + + _proto.render = function render() { + var _this$props = this.props, + Component$$1 = _this$props.component, + childFactory = _this$props.childFactory, + props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]); + + var children = values(this.state.children).map(childFactory); + delete props.appear; + delete props.enter; + delete props.exit; + + if (Component$$1 === null) { + return children; + } + + return _react.default.createElement(Component$$1, props, children); + }; + + return TransitionGroup; +}(_react.default.Component); + +TransitionGroup.childContextTypes = { + transitionGroup: _propTypes.default.object.isRequired +}; +TransitionGroup.propTypes = process.env.NODE_ENV !== "production" ? { + /** + * `` renders a `
` by default. You can change this + * behavior by providing a `component` prop. + * If you use React v16+ and would like to avoid a wrapping `
` element + * you can pass in `component={null}`. This is useful if the wrapping div + * borks your css styles. + */ + component: _propTypes.default.any, + + /** + * A set of `` components, that are toggled `in` and out as they + * leave. the `` will inject specific transition props, so + * remember to spread them through if you are wrapping the `` as + * with our `` example. + */ + children: _propTypes.default.node, + + /** + * A convenience prop that enables or disables appear animations + * for all children. Note that specifying this will override any defaults set + * on individual children Transitions. + */ + appear: _propTypes.default.bool, + + /** + * A convenience prop that enables or disables enter animations + * for all children. Note that specifying this will override any defaults set + * on individual children Transitions. + */ + enter: _propTypes.default.bool, + + /** + * A convenience prop that enables or disables exit animations + * for all children. Note that specifying this will override any defaults set + * on individual children Transitions. + */ + exit: _propTypes.default.bool, + + /** + * You may need to apply reactive updates to a child as it is exiting. + * This is generally done by using `cloneElement` however in the case of an exiting + * child the element has already been removed and not accessible to the consumer. + * + * If you do need to update a child as it leaves you can provide a `childFactory` + * to wrap every child, even the ones that are leaving. + * + * @type Function(child: ReactElement) -> ReactElement + */ + childFactory: _propTypes.default.func +} : {}; +TransitionGroup.defaultProps = defaultProps; + +var _default = (0, reactLifecyclesCompat_es.polyfill)(TransitionGroup); + +exports.default = _default; +module.exports = exports["default"]; +}); + +unwrapExports(TransitionGroup_1); + +var constant = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.ACTION = exports.TYPE = exports.POSITION = void 0; +var POSITION = { + TOP_LEFT: 'top-left', + TOP_RIGHT: 'top-right', + TOP_CENTER: 'top-center', + BOTTOM_LEFT: 'bottom-left', + BOTTOM_RIGHT: 'bottom-right', + BOTTOM_CENTER: 'bottom-center' +}; +exports.POSITION = POSITION; +var TYPE = { + INFO: 'info', + SUCCESS: 'success', + WARNING: 'warning', + ERROR: 'error', + DEFAULT: 'default' +}; +exports.TYPE = TYPE; +var ACTION = { + SHOW: 0, + CLEAR: 1, + DID_MOUNT: 2, + WILL_UNMOUNT: 3, + ON_CHANGE: 4 +}; +exports.ACTION = ACTION; +}); + +unwrapExports(constant); +var constant_1 = constant.ACTION; +var constant_2 = constant.TYPE; +var constant_3 = constant.POSITION; + +var propValidator = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.isValidDelay = isValidDelay; +exports.objectValues = objectValues; +exports.falseOrElement = exports.falseOrDelay = void 0; + + + +function isValidDelay(val) { + return typeof val === 'number' && !isNaN(val) && val > 0; +} + +function objectValues(obj) { + return Object.keys(obj).map(function (key) { + return obj[key]; + }); +} + +function withRequired(fn) { + fn.isRequired = function (props, propName, componentName) { + var prop = props[propName]; + + if (typeof prop === 'undefined') { + return new Error("The prop " + propName + " is marked as required in \n " + componentName + ", but its value is undefined."); + } + + fn(props, propName, componentName); + }; + + return fn; +} + +var falseOrDelay = withRequired(function (props, propName, componentName) { + var prop = props[propName]; + + if (prop !== false && !isValidDelay(prop)) { + return new Error(componentName + " expect " + propName + " \n to be a valid Number > 0 or equal to false. " + prop + " given."); + } + + return null; +}); +exports.falseOrDelay = falseOrDelay; +var falseOrElement = withRequired(function (props, propName, componentName) { + var prop = props[propName]; + + if (prop !== false && !(0, React.isValidElement)(prop)) { + return new Error(componentName + " expect " + propName + " \n to be a valid react element or equal to false. " + prop + " given."); + } + + return null; +}); +exports.falseOrElement = falseOrElement; +}); + +unwrapExports(propValidator); +var propValidator_1 = propValidator.isValidDelay; +var propValidator_2 = propValidator.objectValues; +var propValidator_3 = propValidator.falseOrElement; +var propValidator_4 = propValidator.falseOrDelay; + +var ProgressBar_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; + +var _react = _interopRequireDefault(React); + +var _propTypes = _interopRequireDefault(require$$0); + +var _classnames = _interopRequireDefault(classnames); + + + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +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); } + +function ProgressBar(_ref) { + var _animationEvent; + + var delay = _ref.delay, + isRunning = _ref.isRunning, + closeToast = _ref.closeToast, + type = _ref.type, + hide = _ref.hide, + className = _ref.className, + userStyle = _ref.style, + controlledProgress = _ref.controlledProgress, + progress = _ref.progress, + isProgressDone = _ref.isProgressDone, + rtl = _ref.rtl; + + var style = _extends({}, userStyle, { + animationDuration: delay + "ms", + animationPlayState: isRunning ? 'running' : 'paused', + opacity: hide ? 0 : 1, + transform: controlledProgress ? "scaleX(" + progress + ")" : null + }); + + var classNames = (0, _classnames.default)('Toastify__progress-bar', controlledProgress ? 'Toastify__progress-bar--controlled' : 'Toastify__progress-bar--animated', "Toastify__progress-bar--" + type, { + 'Toastify__progress-bar--rtl': rtl + }, className); + var animationEvent = (_animationEvent = {}, _animationEvent[controlledProgress && isProgressDone ? 'onTransitionEnd' : 'onAnimationEnd'] = controlledProgress && !isProgressDone ? null : closeToast, _animationEvent); + return _react.default.createElement("div", _extends({ + className: classNames, + style: style + }, animationEvent)); +} + +ProgressBar.propTypes = { + /** + * The animation delay which determine when to close the toast + */ + delay: propValidator.falseOrDelay.isRequired, + + /** + * Whether or not the animation is running or paused + */ + isRunning: _propTypes.default.bool.isRequired, + + /** + * Func to close the current toast + */ + closeToast: _propTypes.default.func.isRequired, + + /** + * Support rtl content + */ + rtl: _propTypes.default.bool.isRequired, + + /** + * Optional type : info, success ... + */ + type: _propTypes.default.string, + + /** + * Hide or not the progress bar + */ + hide: _propTypes.default.bool, + + /** + * Optionnal className + */ + className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + + /** + * Controlled progress value + */ + progress: _propTypes.default.number, + + /** + * Tell wether or not controlled progress bar is used + */ + controlledProgress: _propTypes.default.bool, + + /** + * Helper to close the toast when using controlled progress value + */ + isProgressDone: _propTypes.default.bool +}; +ProgressBar.defaultProps = { + type: constant.TYPE.DEFAULT, + hide: false +}; +var _default = ProgressBar; +exports.default = _default; +}); + +unwrapExports(ProgressBar_1); + +var Toast_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; + +var _react = _interopRequireWildcard(React); + +var _propTypes = _interopRequireDefault(require$$0); + +var _classnames = _interopRequireDefault(classnames); + +var _ProgressBar = _interopRequireDefault(ProgressBar_1); + + + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +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); } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +function getX(e) { + return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientX : e.clientX; +} + +function getY(e) { + return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientY : e.clientY; +} + +var noop = function noop() {}; + +var Toast = +/*#__PURE__*/ +function (_Component) { + _inheritsLoose(Toast, _Component); + + function Toast() { + var _this; + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _Component.call.apply(_Component, [this].concat(args)) || this; + _this.state = { + isRunning: true, + preventExitTransition: false + }; + _this.flag = { + canCloseOnClick: true, + canDrag: false + }; + _this.drag = { + start: 0, + x: 0, + y: 0, + deltaX: 0, + removalDistance: 0 + }; + _this.ref = null; + + _this.pauseToast = function () { + if (_this.props.autoClose) { + _this.setState({ + isRunning: false + }); + } + }; + + _this.playToast = function () { + if (_this.props.autoClose) { + _this.setState({ + isRunning: true + }); + } + }; + + _this.onDragStart = function (e) { + _this.flag.canCloseOnClick = true; + _this.flag.canDrag = true; + _this.ref.style.transition = ''; + _this.drag.start = _this.drag.x = getX(e.nativeEvent); + _this.drag.removalDistance = _this.ref.offsetWidth * (_this.props.draggablePercent / 100); + }; + + _this.onDragMove = function (e) { + if (_this.flag.canDrag) { + if (_this.state.isRunning) { + _this.pauseToast(); + } + + _this.drag.x = getX(e); + _this.drag.deltaX = _this.drag.x - _this.drag.start; // prevent false positif during a toast click + + _this.drag.start !== _this.drag.x && (_this.flag.canCloseOnClick = false); + _this.ref.style.transform = "translateX(" + _this.drag.deltaX + "px)"; + _this.ref.style.opacity = 1 - Math.abs(_this.drag.deltaX / _this.drag.removalDistance); + } + }; + + _this.onDragEnd = function (e) { + if (_this.flag.canDrag) { + _this.flag.canDrag = false; + + if (Math.abs(_this.drag.deltaX) > _this.drag.removalDistance) { + _this.setState({ + preventExitTransition: true + }, _this.props.closeToast); + + return; + } + + _this.drag.y = getY(e); + _this.ref.style.transition = 'transform 0.2s, opacity 0.2s'; + _this.ref.style.transform = 'translateX(0)'; + _this.ref.style.opacity = 1; + } + }; + + _this.onDragTransitionEnd = function () { + var _this$ref$getBounding = _this.ref.getBoundingClientRect(), + top = _this$ref$getBounding.top, + bottom = _this$ref$getBounding.bottom, + left = _this$ref$getBounding.left, + right = _this$ref$getBounding.right; + + if (_this.props.pauseOnHover && _this.drag.x >= left && _this.drag.x <= right && _this.drag.y >= top && _this.drag.y <= bottom) { + _this.pauseToast(); + } else { + _this.playToast(); + } + }; + + return _this; + } + + var _proto = Toast.prototype; + + _proto.componentDidMount = function componentDidMount() { + this.props.onOpen(this.props.children.props); + + if (this.props.draggable) { + this.bindDragEvents(); + } // Maybe I could bind the event in the ToastContainer and rely on delegation + + + if (this.props.pauseOnFocusLoss) { + this.bindFocusEvents(); + } + }; + + _proto.componentDidUpdate = function componentDidUpdate(prevProps) { + if (prevProps.draggable !== this.props.draggable) { + if (this.props.draggable) { + this.bindDragEvents(); + } else { + this.unbindDragEvents(); + } + } + + if (prevProps.pauseOnFocusLoss !== this.props.pauseOnFocusLoss) { + if (this.props.pauseOnFocusLoss) { + this.bindFocusEvents(); + } else { + this.unbindFocusEvents(); + } + } + }; + + _proto.componentWillUnmount = function componentWillUnmount() { + this.props.onClose(this.props.children.props); + + if (this.props.draggable) { + this.unbindDragEvents(); + } + + if (this.props.pauseOnFocusLoss) { + this.unbindFocusEvents(); + } + }; + + _proto.bindFocusEvents = function bindFocusEvents() { + window.addEventListener('focus', this.playToast); + window.addEventListener('blur', this.pauseToast); + }; + + _proto.unbindFocusEvents = function unbindFocusEvents() { + window.removeEventListener('focus', this.playToast); + window.removeEventListener('blur', this.pauseToast); + }; + + _proto.bindDragEvents = function bindDragEvents() { + document.addEventListener('mousemove', this.onDragMove); + document.addEventListener('mouseup', this.onDragEnd); + document.addEventListener('touchmove', this.onDragMove); + document.addEventListener('touchend', this.onDragEnd); + }; + + _proto.unbindDragEvents = function unbindDragEvents() { + document.removeEventListener('mousemove', this.onDragMove); + document.removeEventListener('mouseup', this.onDragEnd); + document.removeEventListener('touchmove', this.onDragMove); + document.removeEventListener('touchend', this.onDragEnd); + }; + + _proto.render = function render() { + var _this2 = this; + + var _this$props = this.props, + closeButton = _this$props.closeButton, + children = _this$props.children, + autoClose = _this$props.autoClose, + pauseOnHover = _this$props.pauseOnHover, + closeOnClick = _this$props.closeOnClick, + type = _this$props.type, + hideProgressBar = _this$props.hideProgressBar, + closeToast = _this$props.closeToast, + Transition = _this$props.transition, + position = _this$props.position, + onExited = _this$props.onExited, + className = _this$props.className, + bodyClassName = _this$props.bodyClassName, + progressClassName = _this$props.progressClassName, + progressStyle = _this$props.progressStyle, + updateId = _this$props.updateId, + role = _this$props.role, + progress = _this$props.progress, + isProgressDone = _this$props.isProgressDone, + rtl = _this$props.rtl; + var toastProps = { + className: (0, _classnames.default)('Toastify__toast', "Toastify__toast--" + type, { + 'Toastify__toast--rtl': rtl + }, className) + }; + + if (autoClose && pauseOnHover) { + toastProps.onMouseEnter = this.pauseToast; + toastProps.onMouseLeave = this.playToast; + } // prevent toast from closing when user drags the toast + + + if (closeOnClick) { + toastProps.onClick = function () { + return _this2.flag.canCloseOnClick && closeToast(); + }; + } + + var controlledProgress = parseFloat(progress) === progress; + return _react.default.createElement(Transition, { + in: this.props.in, + appear: true, + unmountOnExit: true, + onExited: onExited, + position: position, + preventExitTransition: this.state.preventExitTransition + }, _react.default.createElement("div", _extends({}, toastProps, { + ref: function ref(_ref) { + return _this2.ref = _ref; + }, + onMouseDown: this.onDragStart, + onTouchStart: this.onDragStart, + onTransitionEnd: this.onDragTransitionEnd + }), _react.default.createElement("div", _extends({}, this.props.in && { + role: role + }, { + className: (0, _classnames.default)('Toastify__toast-body', bodyClassName) + }), children), closeButton && closeButton, (autoClose || controlledProgress) && _react.default.createElement(_ProgressBar.default, _extends({}, updateId && !controlledProgress ? { + key: "pb-" + updateId + } : {}, { + rtl: rtl, + delay: autoClose, + isRunning: this.state.isRunning, + closeToast: closeToast, + hide: hideProgressBar, + type: type, + style: progressStyle, + className: progressClassName, + controlledProgress: controlledProgress, + isProgressDone: isProgressDone, + progress: progress + })))); + }; + + return Toast; +}(_react.Component); + +Toast.propTypes = { + closeButton: propValidator.falseOrElement.isRequired, + autoClose: propValidator.falseOrDelay.isRequired, + children: _propTypes.default.node.isRequired, + closeToast: _propTypes.default.func.isRequired, + position: _propTypes.default.oneOf((0, propValidator.objectValues)(constant.POSITION)).isRequired, + pauseOnHover: _propTypes.default.bool.isRequired, + pauseOnFocusLoss: _propTypes.default.bool.isRequired, + closeOnClick: _propTypes.default.bool.isRequired, + transition: _propTypes.default.func.isRequired, + rtl: _propTypes.default.bool.isRequired, + hideProgressBar: _propTypes.default.bool.isRequired, + draggable: _propTypes.default.bool.isRequired, + draggablePercent: _propTypes.default.number.isRequired, + in: _propTypes.default.bool, + onExited: _propTypes.default.func, + onOpen: _propTypes.default.func, + onClose: _propTypes.default.func, + type: _propTypes.default.oneOf((0, propValidator.objectValues)(constant.TYPE)), + className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + bodyClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + progressClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + progressStyle: _propTypes.default.object, + progress: _propTypes.default.number, + isProgressDone: _propTypes.default.bool, + updateId: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]), + ariaLabel: _propTypes.default.string +}; +Toast.defaultProps = { + type: constant.TYPE.DEFAULT, + in: true, + onOpen: noop, + onClose: noop, + className: null, + bodyClassName: null, + progressClassName: null, + updateId: null, + role: 'alert' +}; +var _default = Toast; +exports.default = _default; +}); + +unwrapExports(Toast_1); + +var CloseButton_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; + +var _react = _interopRequireDefault(React); + +var _propTypes = _interopRequireDefault(require$$0); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function CloseButton(_ref) { + var closeToast = _ref.closeToast, + type = _ref.type, + ariaLabel = _ref.ariaLabel; + return _react.default.createElement("button", { + className: "Toastify__close-button Toastify__close-button--" + type, + type: "button", + onClick: closeToast, + "aria-label": ariaLabel + }, "\u2716"); +} + +CloseButton.propTypes = { + closeToast: _propTypes.default.func, + arialLabel: _propTypes.default.string +}; +CloseButton.defaultProps = { + ariaLabel: 'close' +}; +var _default = CloseButton; +exports.default = _default; +}); + +unwrapExports(CloseButton_1); + +var PropTypes = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.classNamesShape = exports.timeoutsShape = void 0; + +var _propTypes = _interopRequireDefault(require$$0); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var timeoutsShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({ + enter: _propTypes.default.number, + exit: _propTypes.default.number, + appear: _propTypes.default.number +}).isRequired]) : null; +exports.timeoutsShape = timeoutsShape; +var classNamesShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.shape({ + enter: _propTypes.default.string, + exit: _propTypes.default.string, + active: _propTypes.default.string +}), _propTypes.default.shape({ + enter: _propTypes.default.string, + enterDone: _propTypes.default.string, + enterActive: _propTypes.default.string, + exit: _propTypes.default.string, + exitDone: _propTypes.default.string, + exitActive: _propTypes.default.string +})]) : null; +exports.classNamesShape = classNamesShape; +}); + +unwrapExports(PropTypes); +var PropTypes_1 = PropTypes.classNamesShape; +var PropTypes_2 = PropTypes.timeoutsShape; + +var Transition_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = void 0; + +var PropTypes$$1 = _interopRequireWildcard(require$$0); + +var _react = _interopRequireDefault(React); + +var _reactDom = _interopRequireDefault(reactDom); + + + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +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; } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +var UNMOUNTED = 'unmounted'; +exports.UNMOUNTED = UNMOUNTED; +var EXITED = 'exited'; +exports.EXITED = EXITED; +var ENTERING = 'entering'; +exports.ENTERING = ENTERING; +var ENTERED = 'entered'; +exports.ENTERED = ENTERED; +var EXITING = 'exiting'; +/** + * The Transition component lets you describe a transition from one component + * state to another _over time_ with a simple declarative API. Most commonly + * it's used to animate the mounting and unmounting of a component, but can also + * be used to describe in-place transition states as well. + * + * By default the `Transition` component does not alter the behavior of the + * component it renders, it only tracks "enter" and "exit" states for the components. + * It's up to you to give meaning and effect to those states. For example we can + * add styles to a component when it enters or exits: + * + * ```jsx + * import Transition from 'react-transition-group/Transition'; + * + * const duration = 300; + * + * const defaultStyle = { + * transition: `opacity ${duration}ms ease-in-out`, + * opacity: 0, + * } + * + * const transitionStyles = { + * entering: { opacity: 0 }, + * entered: { opacity: 1 }, + * }; + * + * const Fade = ({ in: inProp }) => ( + * + * {(state) => ( + *
+ * I'm a fade Transition! + *
+ * )} + * + * ); + * ``` + * + * As noted the `Transition` component doesn't _do_ anything by itself to its child component. + * What it does do is track transition states over time so you can update the + * component (such as by adding styles or classes) when it changes states. + * + * There are 4 main states a Transition can be in: + * - `'entering'` + * - `'entered'` + * - `'exiting'` + * - `'exited'` + * + * Transition state is toggled via the `in` prop. When `true` the component begins the + * "Enter" stage. During this stage, the component will shift from its current transition state, + * to `'entering'` for the duration of the transition and then to the `'entered'` stage once + * it's complete. Let's take the following example: + * + * ```jsx + * state = { in: false }; + * + * toggleEnterState = () => { + * this.setState({ in: true }); + * } + * + * render() { + * return ( + *
+ * + * + *
+ * ); + * } + * ``` + * + * When the button is clicked the component will shift to the `'entering'` state and + * stay there for 500ms (the value of `timeout`) before it finally switches to `'entered'`. + * + * When `in` is `false` the same thing happens except the state moves from `'exiting'` to `'exited'`. + * + * ## Timing + * + * Timing is often the trickiest part of animation, mistakes can result in slight delays + * that are hard to pin down. A common example is when you want to add an exit transition, + * you should set the desired final styles when the state is `'exiting'`. That's when the + * transition to those styles will start and, if you matched the `timeout` prop with the + * CSS Transition duration, it will end exactly when the state changes to `'exited'`. + * + * > **Note**: For simpler transitions the `Transition` component might be enough, but + * > take into account that it's platform-agnostic, while the `CSSTransition` component + * > [forces reflows](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215) + * > in order to make more complex transitions more predictable. For example, even though + * > classes `example-enter` and `example-enter-active` are applied immediately one after + * > another, you can still transition from one to the other because of the forced reflow + * > (read [this issue](https://github.com/reactjs/react-transition-group/issues/159#issuecomment-322761171) + * > for more info). Take this into account when choosing between `Transition` and + * > `CSSTransition`. + */ + +exports.EXITING = EXITING; + +var Transition = +/*#__PURE__*/ +function (_React$Component) { + _inheritsLoose(Transition, _React$Component); + + function Transition(props, context) { + var _this; + + _this = _React$Component.call(this, props, context) || this; + var parentGroup = context.transitionGroup; // In the context of a TransitionGroup all enters are really appears + + var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear; + var initialStatus; + _this.appearStatus = null; + + if (props.in) { + if (appear) { + initialStatus = EXITED; + _this.appearStatus = ENTERING; + } else { + initialStatus = ENTERED; + } + } else { + if (props.unmountOnExit || props.mountOnEnter) { + initialStatus = UNMOUNTED; + } else { + initialStatus = EXITED; + } + } + + _this.state = { + status: initialStatus + }; + _this.nextCallback = null; + return _this; + } + + var _proto = Transition.prototype; + + _proto.getChildContext = function getChildContext() { + return { + transitionGroup: null // allows for nested Transitions + + }; + }; + + Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) { + var nextIn = _ref.in; + + if (nextIn && prevState.status === UNMOUNTED) { + return { + status: EXITED + }; + } + + return null; + }; // getSnapshotBeforeUpdate(prevProps) { + // let nextStatus = null + // if (prevProps !== this.props) { + // const { status } = this.state + // if (this.props.in) { + // if (status !== ENTERING && status !== ENTERED) { + // nextStatus = ENTERING + // } + // } else { + // if (status === ENTERING || status === ENTERED) { + // nextStatus = EXITING + // } + // } + // } + // return { nextStatus } + // } + + + _proto.componentDidMount = function componentDidMount() { + this.updateStatus(true, this.appearStatus); + }; + + _proto.componentDidUpdate = function componentDidUpdate(prevProps) { + var nextStatus = null; + + if (prevProps !== this.props) { + var status = this.state.status; + + if (this.props.in) { + if (status !== ENTERING && status !== ENTERED) { + nextStatus = ENTERING; + } + } else { + if (status === ENTERING || status === ENTERED) { + nextStatus = EXITING; + } + } + } + + this.updateStatus(false, nextStatus); + }; + + _proto.componentWillUnmount = function componentWillUnmount() { + this.cancelNextCallback(); + }; + + _proto.getTimeouts = function getTimeouts() { + var timeout = this.props.timeout; + var exit, enter, appear; + exit = enter = appear = timeout; + + if (timeout != null && typeof timeout !== 'number') { + exit = timeout.exit; + enter = timeout.enter; // TODO: remove fallback for next major + + appear = timeout.appear !== undefined ? timeout.appear : enter; + } + + return { + exit: exit, + enter: enter, + appear: appear + }; + }; + + _proto.updateStatus = function updateStatus(mounting, nextStatus) { + if (mounting === void 0) { + mounting = false; + } + + if (nextStatus !== null) { + // nextStatus will always be ENTERING or EXITING. + this.cancelNextCallback(); + + var node = _reactDom.default.findDOMNode(this); + + if (nextStatus === ENTERING) { + this.performEnter(node, mounting); + } else { + this.performExit(node); + } + } else if (this.props.unmountOnExit && this.state.status === EXITED) { + this.setState({ + status: UNMOUNTED + }); + } + }; + + _proto.performEnter = function performEnter(node, mounting) { + var _this2 = this; + + var enter = this.props.enter; + var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting; + var timeouts = this.getTimeouts(); + var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED + // if we are mounting and running this it means appear _must_ be set + + if (!mounting && !enter) { + this.safeSetState({ + status: ENTERED + }, function () { + _this2.props.onEntered(node); + }); + return; + } + + this.props.onEnter(node, appearing); + this.safeSetState({ + status: ENTERING + }, function () { + _this2.props.onEntering(node, appearing); + + _this2.onTransitionEnd(node, enterTimeout, function () { + _this2.safeSetState({ + status: ENTERED + }, function () { + _this2.props.onEntered(node, appearing); + }); + }); + }); + }; + + _proto.performExit = function performExit(node) { + var _this3 = this; + + var exit = this.props.exit; + var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED + + if (!exit) { + this.safeSetState({ + status: EXITED + }, function () { + _this3.props.onExited(node); + }); + return; + } + + this.props.onExit(node); + this.safeSetState({ + status: EXITING + }, function () { + _this3.props.onExiting(node); + + _this3.onTransitionEnd(node, timeouts.exit, function () { + _this3.safeSetState({ + status: EXITED + }, function () { + _this3.props.onExited(node); + }); + }); + }); + }; + + _proto.cancelNextCallback = function cancelNextCallback() { + if (this.nextCallback !== null) { + this.nextCallback.cancel(); + this.nextCallback = null; + } + }; + + _proto.safeSetState = function safeSetState(nextState, callback) { + // This shouldn't be necessary, but there are weird race conditions with + // setState callbacks and unmounting in testing, so always make sure that + // we can cancel any pending setState callbacks after we unmount. + callback = this.setNextCallback(callback); + this.setState(nextState, callback); + }; + + _proto.setNextCallback = function setNextCallback(callback) { + var _this4 = this; + + var active = true; + + this.nextCallback = function (event) { + if (active) { + active = false; + _this4.nextCallback = null; + callback(event); + } + }; + + this.nextCallback.cancel = function () { + active = false; + }; + + return this.nextCallback; + }; + + _proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) { + this.setNextCallback(handler); + + if (node) { + if (this.props.addEndListener) { + this.props.addEndListener(node, this.nextCallback); + } + + if (timeout != null) { + setTimeout(this.nextCallback, timeout); + } + } else { + setTimeout(this.nextCallback, 0); + } + }; + + _proto.render = function render() { + var status = this.state.status; + + if (status === UNMOUNTED) { + return null; + } + + var _this$props = this.props, + children = _this$props.children, + childProps = _objectWithoutPropertiesLoose(_this$props, ["children"]); // filter props for Transtition + + + delete childProps.in; + delete childProps.mountOnEnter; + delete childProps.unmountOnExit; + delete childProps.appear; + delete childProps.enter; + delete childProps.exit; + delete childProps.timeout; + delete childProps.addEndListener; + delete childProps.onEnter; + delete childProps.onEntering; + delete childProps.onEntered; + delete childProps.onExit; + delete childProps.onExiting; + delete childProps.onExited; + + if (typeof children === 'function') { + return children(status, childProps); + } + + var child = _react.default.Children.only(children); + + return _react.default.cloneElement(child, childProps); + }; + + return Transition; +}(_react.default.Component); + +Transition.contextTypes = { + transitionGroup: PropTypes$$1.object +}; +Transition.childContextTypes = { + transitionGroup: function transitionGroup() {} +}; +Transition.propTypes = process.env.NODE_ENV !== "production" ? { + /** + * A `function` child can be used instead of a React element. + * This function is called with the current transition status + * ('entering', 'entered', 'exiting', 'exited', 'unmounted'), which can be used + * to apply context specific props to a component. + * + * ```jsx + * + * {(status) => ( + * + * )} + * + * ``` + */ + children: PropTypes$$1.oneOfType([PropTypes$$1.func.isRequired, PropTypes$$1.element.isRequired]).isRequired, + + /** + * Show the component; triggers the enter or exit states + */ + in: PropTypes$$1.bool, + + /** + * By default the child component is mounted immediately along with + * the parent `Transition` component. If you want to "lazy mount" the component on the + * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay + * mounted, even on "exited", unless you also specify `unmountOnExit`. + */ + mountOnEnter: PropTypes$$1.bool, + + /** + * By default the child component stays mounted after it reaches the `'exited'` state. + * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting. + */ + unmountOnExit: PropTypes$$1.bool, + + /** + * Normally a component is not transitioned if it is shown when the `` component mounts. + * If you want to transition on the first mount set `appear` to `true`, and the + * component will transition in as soon as the `` mounts. + * + * > Note: there are no specific "appear" states. `appear` only adds an additional `enter` transition. + */ + appear: PropTypes$$1.bool, + + /** + * Enable or disable enter transitions. + */ + enter: PropTypes$$1.bool, + + /** + * Enable or disable exit transitions. + */ + exit: PropTypes$$1.bool, + + /** + * The duration of the transition, in milliseconds. + * Required unless `addEndListener` is provided + * + * You may specify a single timeout for all transitions like: `timeout={500}`, + * or individually like: + * + * ```jsx + * timeout={{ + * enter: 300, + * exit: 500, + * appear: 500, + * }} + * ``` + * + * If the value of appear is not set, then the value from enter is taken. + * + * @type {number | { enter?: number, exit?: number }} + */ + timeout: function timeout(props) { + var pt = process.env.NODE_ENV !== "production" ? PropTypes.timeoutsShape : {}; if (!props.addEndListener) pt = pt.isRequired; + + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return pt.apply(void 0, [props].concat(args)); + }, + + /** + * Add a custom transition end trigger. Called with the transitioning + * DOM node and a `done` callback. Allows for more fine grained transition end + * logic. **Note:** Timeouts are still used as a fallback if provided. + * + * ```jsx + * addEndListener={(node, done) => { + * // use the css transitionend event to mark the finish of a transition + * node.addEventListener('transitionend', done, false); + * }} + * ``` + */ + addEndListener: PropTypes$$1.func, + + /** + * Callback fired before the "entering" status is applied. An extra parameter + * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount + * + * @type Function(node: HtmlElement, isAppearing: bool) -> void + */ + onEnter: PropTypes$$1.func, + + /** + * Callback fired after the "entering" status is applied. An extra parameter + * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount + * + * @type Function(node: HtmlElement, isAppearing: bool) + */ + onEntering: PropTypes$$1.func, + + /** + * Callback fired after the "entered" status is applied. An extra parameter + * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount + * + * @type Function(node: HtmlElement, isAppearing: bool) -> void + */ + onEntered: PropTypes$$1.func, + + /** + * Callback fired before the "exiting" status is applied. + * + * @type Function(node: HtmlElement) -> void + */ + onExit: PropTypes$$1.func, + + /** + * Callback fired after the "exiting" status is applied. + * + * @type Function(node: HtmlElement) -> void + */ + onExiting: PropTypes$$1.func, + + /** + * Callback fired after the "exited" status is applied. + * + * @type Function(node: HtmlElement) -> void + */ + onExited: PropTypes$$1.func // Name the function so it is clearer in the documentation + +} : {}; + +function noop() {} + +Transition.defaultProps = { + in: false, + mountOnEnter: false, + unmountOnExit: false, + appear: false, + enter: true, + exit: true, + onEnter: noop, + onEntering: noop, + onEntered: noop, + onExit: noop, + onExiting: noop, + onExited: noop +}; +Transition.UNMOUNTED = 0; +Transition.EXITED = 1; +Transition.ENTERING = 2; +Transition.ENTERED = 3; +Transition.EXITING = 4; + +var _default = (0, reactLifecyclesCompat_es.polyfill)(Transition); + +exports.default = _default; +}); + +unwrapExports(Transition_1); +var Transition_2 = Transition_1.EXITING; +var Transition_3 = Transition_1.ENTERED; +var Transition_4 = Transition_1.ENTERING; +var Transition_5 = Transition_1.EXITED; +var Transition_6 = Transition_1.UNMOUNTED; + +var cssTransition = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = _default; + +var _react = _interopRequireDefault(React); + +var _Transition = _interopRequireDefault(Transition_1); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +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); } + +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; } + +var noop = function noop() {}; + +function _default(_ref) { + var enter = _ref.enter, + exit = _ref.exit, + _ref$duration = _ref.duration, + duration = _ref$duration === void 0 ? 750 : _ref$duration, + _ref$appendPosition = _ref.appendPosition, + appendPosition = _ref$appendPosition === void 0 ? false : _ref$appendPosition; + return function Animation(_ref2) { + var children = _ref2.children, + position = _ref2.position, + preventExitTransition = _ref2.preventExitTransition, + props = _objectWithoutPropertiesLoose(_ref2, ["children", "position", "preventExitTransition"]); + + var enterClassName = appendPosition ? enter + "--" + position : enter; + var exitClassName = appendPosition ? exit + "--" + position : exit; + var enterDuration, exitDuration; + + if (Array.isArray(duration) && duration.length === 2) { + enterDuration = duration[0]; + exitDuration = duration[1]; + } else { + enterDuration = exitDuration = duration; + } + + var onEnter = function onEnter(node) { + node.classList.add(enterClassName); + node.style.animationFillMode = 'forwards'; + node.style.animationDuration = enterDuration * 0.001 + "s"; + }; + + var onEntered = function onEntered(node) { + node.classList.remove(enterClassName); + node.style.cssText = ''; + }; + + var onExit = function onExit(node) { + node.classList.add(exitClassName); + node.style.animationFillMode = 'forwards'; + node.style.animationDuration = exitDuration * 0.001 + "s"; + }; + + return _react.default.createElement(_Transition.default, _extends({}, props, { + timeout: preventExitTransition ? 0 : { + enter: enterDuration, + exit: exitDuration + }, + onEnter: onEnter, + onEntered: onEntered, + onExit: preventExitTransition ? noop : onExit + }), children); + }; +} +}); + +unwrapExports(cssTransition); + +var Transitions = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.Flip = exports.Zoom = exports.Slide = exports.Bounce = void 0; + +var _cssTransition = _interopRequireDefault(cssTransition); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var Bounce = (0, _cssTransition.default)({ + enter: 'Toastify__bounce-enter', + exit: 'Toastify__bounce-exit', + appendPosition: true +}); +exports.Bounce = Bounce; +var Slide = (0, _cssTransition.default)({ + enter: 'Toastify__slide-enter', + exit: 'Toastify__slide-exit', + duration: [450, 750], + appendPosition: true +}); +exports.Slide = Slide; +var Zoom = (0, _cssTransition.default)({ + enter: 'Toastify__zoom-enter', + exit: 'Toastify__zoom-exit' +}); +exports.Zoom = Zoom; +var Flip = (0, _cssTransition.default)({ + enter: 'Toastify__flip-enter', + exit: 'Toastify__flip-exit' +}); +exports.Flip = Flip; +}); + +unwrapExports(Transitions); +var Transitions_1 = Transitions.Flip; +var Transitions_2 = Transitions.Zoom; +var Transitions_3 = Transitions.Slide; +var Transitions_4 = Transitions.Bounce; + +var eventManager_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; +var eventManager = { + list: new Map(), + on: function on(event, callback) { + this.list.has(event) || this.list.set(event, []); + this.list.get(event).push(callback); + return this; + }, + off: function off(event) { + this.list.delete(event); + return this; + }, + emit: function emit(event) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + if (!this.list.has(event)) { + return false; + } + + this.list.get(event).forEach(function (callback) { + return setTimeout(function () { + return callback.call.apply(callback, [null].concat(args)); + }, 0); + }); + return true; + } +}; +var _default = eventManager; +exports.default = _default; +}); + +unwrapExports(eventManager_1); + +var ToastContainer_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; + +var _react = _interopRequireWildcard(React); + +var _propTypes = _interopRequireDefault(require$$0); + +var _classnames = _interopRequireDefault(classnames); + +var _TransitionGroup = _interopRequireDefault(TransitionGroup_1); + +var _Toast = _interopRequireDefault(Toast_1); + +var _CloseButton = _interopRequireDefault(CloseButton_1); + + + + + +var _eventManager = _interopRequireDefault(eventManager_1); + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } + +function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } + +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); } + +function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; } + +var ToastContainer = +/*#__PURE__*/ +function (_Component) { + _inheritsLoose(ToastContainer, _Component); + + function ToastContainer() { + var _this; + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + _this = _Component.call.apply(_Component, [this].concat(args)) || this; + _this.state = { + toast: [] + }; + _this.toastKey = 1; + _this.collection = {}; + + _this.isToastActive = function (id) { + return _this.state.toast.indexOf(id) !== -1; + }; + + return _this; + } + + var _proto = ToastContainer.prototype; + + _proto.componentDidMount = function componentDidMount() { + var _this2 = this; + + _eventManager.default.on(constant.ACTION.SHOW, function (content, options) { + return _this2.show(content, options); + }).on(constant.ACTION.CLEAR, function (id) { + return !id ? _this2.clear() : _this2.removeToast(id); + }).emit(constant.ACTION.DID_MOUNT, this); + }; + + _proto.componentWillUnmount = function componentWillUnmount() { + _eventManager.default.off(constant.ACTION.SHOW).off(constant.ACTION.CLEAR).emit(constant.ACTION.WILL_UNMOUNT); + }; + + _proto.removeToast = function removeToast(id) { + this.setState({ + toast: this.state.toast.filter(function (v) { + return v !== id; + }) + }, this.dispatchChange); + }; + + _proto.dispatchChange = function dispatchChange() { + _eventManager.default.emit(constant.ACTION.ON_CHANGE, this.state.toast.length); + }; + + _proto.makeCloseButton = function makeCloseButton(toastClose, toastId, type) { + var _this3 = this; + + var closeButton = this.props.closeButton; + + if ((0, _react.isValidElement)(toastClose) || toastClose === false) { + closeButton = toastClose; + } + + return closeButton === false ? false : (0, _react.cloneElement)(closeButton, { + closeToast: function closeToast() { + return _this3.removeToast(toastId); + }, + type: type + }); + }; + + _proto.getAutoCloseDelay = function getAutoCloseDelay(toastAutoClose) { + return toastAutoClose === false || (0, propValidator.isValidDelay)(toastAutoClose) ? toastAutoClose : this.props.autoClose; + }; + + _proto.canBeRendered = function canBeRendered(content) { + return (0, _react.isValidElement)(content) || typeof content === 'string' || typeof content === 'number' || typeof content === 'function'; + }; + + _proto.parseClassName = function parseClassName(prop) { + if (typeof prop === 'string') { + return prop; + } else if (prop !== null && typeof prop === 'object' && 'toString' in prop) { + return prop.toString(); + } + + return null; + }; + + _proto.show = function show(content, options) { + var _this4 = this, + _extends2; + + if (!this.canBeRendered(content)) { + throw new Error("The element you provided cannot be rendered. You provided an element of type " + typeof content); + } + + var toastId = options.toastId; + + var closeToast = function closeToast() { + return _this4.removeToast(toastId); + }; + + var toastOptions = { + id: toastId, + // ⚠️ if no options.key, this.toastKey - 1 is assigned + key: options.key || this.toastKey++, + type: options.type, + closeToast: closeToast, + updateId: options.updateId, + rtl: this.props.rtl, + position: options.position || this.props.position, + transition: options.transition || this.props.transition, + className: this.parseClassName(options.className || this.props.toastClassName), + bodyClassName: this.parseClassName(options.bodyClassName || this.props.bodyClassName), + closeButton: this.makeCloseButton(options.closeButton, toastId, options.type), + pauseOnHover: typeof options.pauseOnHover === 'boolean' ? options.pauseOnHover : this.props.pauseOnHover, + pauseOnFocusLoss: typeof options.pauseOnFocusLoss === 'boolean' ? options.pauseOnFocusLoss : this.props.pauseOnFocusLoss, + draggable: typeof options.draggable === 'boolean' ? options.draggable : this.props.draggable, + draggablePercent: typeof options.draggablePercent === 'number' && !isNaN(options.draggablePercent) ? options.draggablePercent : this.props.draggablePercent, + closeOnClick: typeof options.closeOnClick === 'boolean' ? options.closeOnClick : this.props.closeOnClick, + progressClassName: this.parseClassName(options.progressClassName || this.props.progressClassName), + progressStyle: this.props.progressStyle, + autoClose: this.getAutoCloseDelay(options.autoClose), + hideProgressBar: typeof options.hideProgressBar === 'boolean' ? options.hideProgressBar : this.props.hideProgressBar, + progress: parseFloat(options.progress), + isProgressDone: options.isProgressDone + }; + typeof options.onOpen === 'function' && (toastOptions.onOpen = options.onOpen); + typeof options.onClose === 'function' && (toastOptions.onClose = options.onClose); // add closeToast function to react component only + + if ((0, _react.isValidElement)(content) && typeof content.type !== 'string' && typeof content.type !== 'number') { + content = (0, _react.cloneElement)(content, { + closeToast: closeToast + }); + } else if (typeof content === 'function') { + content = content({ + closeToast: closeToast + }); + } + + this.collection = _extends({}, this.collection, (_extends2 = {}, _extends2[toastId] = { + position: toastOptions.position, + options: toastOptions, + content: content + }, _extends2)); + this.setState({ + toast: (toastOptions.updateId ? _toConsumableArray(this.state.toast) : _toConsumableArray(this.state.toast).concat([toastId])).filter(function (id) { + return id !== options.staleToastId; + }) + }, this.dispatchChange); + }; + + _proto.makeToast = function makeToast(content, options) { + return _react.default.createElement(_Toast.default, _extends({}, options, { + isDocumentHidden: this.state.isDocumentHidden, + key: "toast-" + options.key + }), content); + }; + + _proto.clear = function clear() { + this.setState({ + toast: [] + }); + }; + + _proto.renderToast = function renderToast() { + var _this5 = this; + + var toastToRender = {}; + var _this$props = this.props, + className = _this$props.className, + style = _this$props.style, + newestOnTop = _this$props.newestOnTop; + var collection = newestOnTop ? Object.keys(this.collection).reverse() : Object.keys(this.collection); // group toast by position + + collection.forEach(function (toastId) { + var _this5$collection$toa = _this5.collection[toastId], + position = _this5$collection$toa.position, + options = _this5$collection$toa.options, + content = _this5$collection$toa.content; + toastToRender[position] || (toastToRender[position] = []); + + if (_this5.state.toast.indexOf(options.id) !== -1) { + toastToRender[position].push(_this5.makeToast(content, options)); + } else { + toastToRender[position].push(null); + delete _this5.collection[toastId]; + } + }); + return Object.keys(toastToRender).map(function (position) { + var disablePointer = toastToRender[position].length === 1 && toastToRender[position][0] === null; + var props = { + className: (0, _classnames.default)('Toastify__toast-container', "Toastify__toast-container--" + position, { + 'Toastify__toast-container--rtl': _this5.props.rtl + }, _this5.parseClassName(className)), + style: disablePointer ? _extends({}, style, { + pointerEvents: 'none' + }) : _extends({}, style) + }; + return _react.default.createElement(_TransitionGroup.default, _extends({}, props, { + key: "container-" + position + }), toastToRender[position]); + }); + }; + + _proto.render = function render() { + return _react.default.createElement("div", { + className: "Toastify" + }, this.renderToast()); + }; + + return ToastContainer; +}(_react.Component); + +ToastContainer.propTypes = { + /** + * Set toast position + */ + position: _propTypes.default.oneOf((0, propValidator.objectValues)(constant.POSITION)), + + /** + * Disable or set autoClose delay + */ + autoClose: propValidator.falseOrDelay, + + /** + * Disable or set a custom react element for the close button + */ + closeButton: propValidator.falseOrElement, + + /** + * Hide or not progress bar when autoClose is enabled + */ + hideProgressBar: _propTypes.default.bool, + + /** + * Pause toast duration on hover + */ + pauseOnHover: _propTypes.default.bool, + + /** + * Dismiss toast on click + */ + closeOnClick: _propTypes.default.bool, + + /** + * Newest on top + */ + newestOnTop: _propTypes.default.bool, + + /** + * An optional className + */ + className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + + /** + * An optional style + */ + style: _propTypes.default.object, + + /** + * An optional className for the toast + */ + toastClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + + /** + * An optional className for the toast body + */ + bodyClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + + /** + * An optional className for the toast progress bar + */ + progressClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]), + + /** + * An optional style for the toast progress bar + */ + progressStyle: _propTypes.default.object, + + /** + * Define enter and exit transition using react-transition-group + */ + transition: _propTypes.default.func, + + /** + * Support rtl display + */ + rtl: _propTypes.default.bool, + + /** + * Allow toast to be draggable + */ + draggable: _propTypes.default.bool, + + /** + * The percentage of the toast's width it takes for a drag to dismiss a toast + */ + draggablePercent: _propTypes.default.number, + + /** + * Pause the toast on focus loss + */ + pauseOnFocusLoss: _propTypes.default.bool +}; +ToastContainer.defaultProps = { + position: constant.POSITION.TOP_RIGHT, + transition: Transitions.Bounce, + rtl: false, + autoClose: 5000, + hideProgressBar: false, + closeButton: _react.default.createElement(_CloseButton.default, null), + pauseOnHover: true, + pauseOnFocusLoss: true, + closeOnClick: true, + newestOnTop: false, + draggable: true, + draggablePercent: 80, + className: null, + style: null, + toastClassName: null, + bodyClassName: null, + progressClassName: null, + progressStyle: null +}; +var _default = ToastContainer; +exports.default = _default; +}); + +unwrapExports(ToastContainer_1); + +var toast_1 = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; +exports.default = void 0; + +var _eventManager = _interopRequireDefault(eventManager_1); + + + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +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 container = null; +var queue = []; + +var noop = function noop() { + return false; +}; +/** + * Merge provided options with the defaults settings and generate the toastId + */ + + +function mergeOptions(options, type) { + return _extends({}, options, { + type: type, + toastId: getToastId(options) + }); +} +/** + * Generate a random toastId + */ + + +function generateToastId() { + return (Math.random().toString(36) + Date.now().toString(36)).substr(2, 10); +} +/** + * Generate the toastId either automatically or by provided toastId + */ + + +function getToastId(options) { + if (options && (typeof options.toastId === 'string' || typeof options.toastId === 'number' && !isNaN(options.toastId))) { + return options.toastId; + } + + return generateToastId(); +} +/** + * Dispatch toast. If the container is not mounted, the toast is enqueued + */ + + +function emitEvent(content, options) { + if (container !== null) { + _eventManager.default.emit(constant.ACTION.SHOW, content, options); + } else { + queue.push({ + action: constant.ACTION.SHOW, + content: content, + options: options + }); + } + + return options.toastId; +} + +var toast = _extends(function (content, options) { + return emitEvent(content, mergeOptions(options, options && options.type || constant.TYPE.DEFAULT)); +}, { + success: function success(content, options) { + return emitEvent(content, mergeOptions(options, constant.TYPE.SUCCESS)); + }, + info: function info(content, options) { + return emitEvent(content, mergeOptions(options, constant.TYPE.INFO)); + }, + warn: function warn(content, options) { + return emitEvent(content, mergeOptions(options, constant.TYPE.WARNING)); + }, + warning: function warning(content, options) { + return emitEvent(content, mergeOptions(options, constant.TYPE.WARNING)); + }, + error: function error(content, options) { + return emitEvent(content, mergeOptions(options, constant.TYPE.ERROR)); + }, + dismiss: function dismiss(id) { + if (id === void 0) { + id = null; + } + + return container && _eventManager.default.emit(constant.ACTION.CLEAR, id); + }, + isActive: noop, + update: function update(toastId, options) { + setTimeout(function () { + if (container && typeof container.collection[toastId] !== 'undefined') { + var _container$collection = container.collection[toastId], + oldOptions = _container$collection.options, + oldContent = _container$collection.content; + + var nextOptions = _extends({}, oldOptions, options, { + toastId: options.toastId || toastId + }); + + if (!options.toastId || options.toastId === toastId) { + nextOptions.updateId = generateToastId(); + } else { + nextOptions.staleToastId = toastId; + } + + var content = typeof nextOptions.render !== 'undefined' ? nextOptions.render : oldContent; + delete nextOptions.render; + emitEvent(content, nextOptions); + } + }, 0); + }, + done: function done(id, progress) { + if (progress === void 0) { + progress = 1; + } + + toast.update(id, { + progress: progress, + isProgressDone: true + }); + }, + onChange: function onChange(callback) { + if (typeof callback === 'function') { + _eventManager.default.on(constant.ACTION.ON_CHANGE, callback); + } + }, + POSITION: constant.POSITION, + TYPE: constant.TYPE +}); +/** + * Wait until the ToastContainer is mounted to dispatch the toast + * and attach isActive method + */ + + +_eventManager.default.on(constant.ACTION.DID_MOUNT, function (containerInstance) { + container = containerInstance; + + toast.isActive = function (id) { + return container.isToastActive(id); + }; + + queue.forEach(function (item) { + _eventManager.default.emit(item.action, item.content, item.options); + }); + queue = []; +}).on(constant.ACTION.WILL_UNMOUNT, function () { + container = null; + toast.isActive = noop; +}); + +var _default = toast; +exports.default = _default; +}); + +unwrapExports(toast_1); + +var lib = createCommonjsModule(function (module, exports) { + +exports.__esModule = true; + +var _ToastContainer = _interopRequireDefault(ToastContainer_1); + +exports.ToastContainer = _ToastContainer.default; + + + +exports.Bounce = Transitions.Bounce; +exports.Slide = Transitions.Slide; +exports.Zoom = Transitions.Zoom; +exports.Flip = Transitions.Flip; + + + +exports.ToastPosition = constant.POSITION; +exports.ToastType = constant.TYPE; + +var _toast = _interopRequireDefault(toast_1); + +exports.toast = _toast.default; + +var _cssTransition = _interopRequireDefault(cssTransition); + +exports.cssTransition = _cssTransition.default; + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } +}); + +unwrapExports(lib); +var lib_1 = lib.ToastContainer; +var lib_2 = lib.Bounce; +var lib_3 = lib.Slide; +var lib_4 = lib.Zoom; +var lib_5 = lib.Flip; +var lib_6 = lib.ToastPosition; +var lib_7 = lib.ToastType; +var lib_8 = lib.toast; +var lib_9 = lib.cssTransition; + +var Form = function (_Component) { + inherits(Form, _Component); + + function Form(props) { + classCallCheck(this, Form); + + var _this = possibleConstructorReturn(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this, props)); + + _this._onSubmit = function (e) { + e.preventDefault(); + _this.props.onSubmit(); + _this.displayError = true; + return false; + }; + + _this.state = { + data: props.data + }; + + _this.displayError = true; + _this.handleError(props); + return _this; + } + + createClass(Form, [{ + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(props) { + this.handleError(props); + this.setState({ + data: props.data + }); + } + }, { + key: 'handleError', + value: function handleError(props) { + if (props.data && props.data.error && props.toast && this.displayError == true) { + lib_8.error(props.data.error); + this.displayError = false; + } + } + }, { + key: 'render', + value: function render() { + return React.createElement( + FormContext.Provider, + { value: this.state.data }, + React.createElement( + 'form', + { onSubmit: this._onSubmit }, + this.renderError(), + this.props.children + ) + ); + } + }, { + key: 'renderError', + value: function renderError() { + if (this.state.data && this.state.data.error && !this.props.toast) { + return React.createElement( + 'p', + { className: 'alert alert-danger' }, + this.state.data.error + ); + } + + return null; + } + }]); + return Form; +}(Component); + + +Form.defaultProps = { + data: null, + toast: false, + onSubmit: function onSubmit() { + console.log('[Form] submitted'); + } +}; + +var Input = function (_Component) { + inherits(Input, _Component); + + function Input() { + classCallCheck(this, Input); + return possibleConstructorReturn(this, (Input.__proto__ || Object.getPrototypeOf(Input)).apply(this, arguments)); + } + + createClass(Input, [{ + key: "render", + value: function render() { + var _this2 = this; + + return React.createElement( + FormConsumer, + null, + function (data) { + return _this2.renderInput(data); + } + ); + } + }, { + key: "renderInput", + value: function renderInput(data) { + var _this3 = this; + + var props = _extends({}, this.props); + if (props.children) delete props.children; + if (props.onChangeValue) delete props.onChangeValue; + return React.createElement( + "div", + { className: "form-group" }, + this.renderLabel(data), + React.createElement("input", _extends({ onChange: function onChange(e) { + return _this3.props.onChangeValue(e.target.value); + } }, props)), + React.createElement(FormItemError, { name: this.props.name, data: data }) + ); + } + }, { + key: "renderLabel", + value: function renderLabel(data) { + if (this.props.label) { + return React.createElement( + "label", + { htmlFor: this.props.id }, + this.props.label + ); + } + } + }]); + return Input; +}(Component); + + +Input.defaultProps = { + name: 'input', + id: 'input', + className: 'form-control', + type: 'text', + onChangeValue: function onChangeValue(text) {} +}; + +var OptionGroupContext = React.createContext({}); + +var OptionGroupConsumer = function (_Component) { + inherits(OptionGroupConsumer, _Component); + + function OptionGroupConsumer() { + classCallCheck(this, OptionGroupConsumer); + return possibleConstructorReturn(this, (OptionGroupConsumer.__proto__ || Object.getPrototypeOf(OptionGroupConsumer)).apply(this, arguments)); + } + + createClass(OptionGroupConsumer, [{ + key: 'render', + value: function render() { + var _this2 = this; + + return React.createElement( + OptionGroupContext.Consumer, + null, + function (props) { + return _this2.props.children(props); + } + ); + } + }]); + return OptionGroupConsumer; +}(Component); + +var OptionGroup = function (_Component2) { + inherits(OptionGroup, _Component2); + + function OptionGroup() { + var _ref; + + var _temp, _this3, _ret; + + classCallCheck(this, OptionGroup); + + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _ret = (_temp = (_this3 = possibleConstructorReturn(this, (_ref = OptionGroup.__proto__ || Object.getPrototypeOf(OptionGroup)).call.apply(_ref, [this].concat(args))), _this3), _this3._onChange = function (e) { + if (_this3.props.multiple) { + var value = []; + var options = e.target.options; + for (var i = 0, l = options.length; i < l; i++) { + if (options[i].selected) { + value.push(options[i].value); + } + } + _this3.props.onChangeValue(value); + } else { + _this3.props.onChangeValue(e.target.value); + } + }, _temp), possibleConstructorReturn(_this3, _ret); + } + + createClass(OptionGroup, [{ + key: 'render', + value: function render() { + var _this4 = this; + + return React.createElement( + FormConsumer, + null, + function (data) { + return _this4.renderOptionGroup(data); + } + ); + } + }, { + key: 'renderOptionGroup', + value: function renderOptionGroup(data) { + var _this5 = this; + + var props = _extends({}, this.props); + return React.createElement( + 'div', + { className: 'form-group' }, + this.renderLabel(), + React.createElement( + 'select', + _extends({}, this.props.data, props, { onChange: function onChange(e) { + return _this5._onChange(e); + } }), + this.renderChildren() + ), + React.createElement(FormItemError, { name: this.props.name, data: data }) + ); + } + }, { + key: 'renderLabel', + value: function renderLabel() { + if (!this.props.label) return null; + + return React.createElement( + 'label', + { htmlFor: this.props.id }, + this.props.label + ); + } + }, { + key: 'renderChildren', + value: function renderChildren() { + return React.createElement( + OptionGroupContext.Provider, + { value: {} }, + this.props.children + ); + } + }]); + return OptionGroup; +}(Component); + + +OptionGroup.defaultProps = { + name: 'select', + className: 'form-control', + onChangeValue: function onChangeValue(value) {} +}; + +var Option = function (_Component) { + inherits(Option, _Component); + + function Option() { + classCallCheck(this, Option); + return possibleConstructorReturn(this, (Option.__proto__ || Object.getPrototypeOf(Option)).apply(this, arguments)); + } + + createClass(Option, [{ + key: 'render', + value: function render() { + var _this2 = this; + + return React.createElement( + OptionGroupConsumer, + null, + function (data) { + return _this2.renderOption(data); + } + ); + } + }, { + key: 'renderOption', + value: function renderOption(data) { + var props = _extends({}, this.props); + + return React.createElement( + 'option', + props, + this.props.children + ); + } + }]); + return Option; +}(Component); + + +Option.defaultProps = { + value: 'option' +}; + +var RadioGroupContext = React.createContext({}); + +var RadioGroupConsumer = function (_Component) { + inherits(RadioGroupConsumer, _Component); + + function RadioGroupConsumer() { + classCallCheck(this, RadioGroupConsumer); + return possibleConstructorReturn(this, (RadioGroupConsumer.__proto__ || Object.getPrototypeOf(RadioGroupConsumer)).apply(this, arguments)); + } + + createClass(RadioGroupConsumer, [{ + key: 'render', + value: function render() { + var _this2 = this; + + return React.createElement( + RadioGroupContext.Consumer, + null, + function (props) { + return _this2.props.children(props); + } + ); + } + }]); + return RadioGroupConsumer; +}(Component); + +var RadioGroup = function (_Component2) { + inherits(RadioGroup, _Component2); + + function RadioGroup() { + classCallCheck(this, RadioGroup); + return possibleConstructorReturn(this, (RadioGroup.__proto__ || Object.getPrototypeOf(RadioGroup)).apply(this, arguments)); + } + + createClass(RadioGroup, [{ + key: 'render', + value: function render() { + var _this4 = this; + + return React.createElement( + FormConsumer, + null, + function (data) { + return _this4.renderRadioGroup(data); + } + ); + } + }, { + key: 'renderRadioGroup', + value: function renderRadioGroup(data) { + return React.createElement( + 'div', + { className: 'form-options mb-3' }, + this.renderLabel(), + this.renderChildren(), + React.createElement(FormItemError, { name: this.props.name, data: data }) + ); + } + }, { + key: 'renderLabel', + value: function renderLabel() { + if (!this.props.label) return null; + + return React.createElement( + 'p', + { className: 'mb-0 mt-2' }, + this.props.label + ); + } + }, { + key: 'renderChildren', + value: function renderChildren() { + var _this5 = this; + + return React.createElement( + RadioGroupContext.Provider, + { value: { + onChangeValue: function onChangeValue(value) { + return _this5.props.onChangeValue(value); + }, + value: this.props.value + } }, + this.props.children + ); + } + }]); + return RadioGroup; +}(Component); + + +RadioGroup.defaultProps = { + name: 'radio', + onChangeValue: function onChangeValue(value) {} +}; + +var Radio = function (_Component) { + inherits(Radio, _Component); + + function Radio() { + classCallCheck(this, Radio); + return possibleConstructorReturn(this, (Radio.__proto__ || Object.getPrototypeOf(Radio)).apply(this, arguments)); + } + + createClass(Radio, [{ + key: "render", + value: function render() { + var _this2 = this; + + return React.createElement( + RadioGroupConsumer, + null, + function (data) { + return _this2.renderRadio(data); + } + ); + } + }, { + key: "renderRadio", + value: function renderRadio(data) { + var _this3 = this; + + var props = _extends({}, this.props); + if (props.children) delete props.children; + + return React.createElement( + "div", + { className: "form-check" }, + React.createElement("input", _extends({ + type: "radio", + checked: data.value === this.props.value, + onChange: function onChange(e) { + if (e.target.checked) data.onChangeValue(_this3.props.value); + } + }, props)), + this.renderLabel(data) + ); + } + }, { + key: "renderLabel", + value: function renderLabel(data) { + if (this.props.children.length) { + return React.createElement( + "label", + { className: "form-check-label", htmlFor: this.props.id }, + this.props.children + ); + } + } + }]); + return Radio; +}(Component); + + +Radio.defaultProps = { + value: 'option', + className: 'form-check-input' +}; + +var Submit = function (_Component) { + inherits(Submit, _Component); + + function Submit() { + classCallCheck(this, Submit); + return possibleConstructorReturn(this, (Submit.__proto__ || Object.getPrototypeOf(Submit)).apply(this, arguments)); + } + + createClass(Submit, [{ + key: 'render', + value: function render() { + return React.createElement( + 'button', + _extends({ type: 'submit' }, this.props), + this.props.children + ); + } + }]); + return Submit; +}(Component); + + +Submit.defaultProps = { + className: 'btn btn-primary' +}; + +var TextArea = function (_Component) { + inherits(TextArea, _Component); + + function TextArea() { + classCallCheck(this, TextArea); + return possibleConstructorReturn(this, (TextArea.__proto__ || Object.getPrototypeOf(TextArea)).apply(this, arguments)); + } + + createClass(TextArea, [{ + key: "render", + value: function render() { + var _this2 = this; + + return React.createElement( + FormConsumer, + null, + function (data) { + return _this2.renderTextArea(data); + } + ); + } + }, { + key: "renderTextArea", + value: function renderTextArea(data) { + var _this3 = this; + + var props = _extends({}, this.props); + if (props.onChangeValue) delete props.onChangeValue; + return React.createElement( + "div", + { className: "form-group" }, + this.renderLabel(data), + React.createElement("textarea", _extends({ onChange: function onChange(e) { + return _this3.props.onChangeValue(e.target.value); + } }, props)), + React.createElement(FormItemError, { name: this.props.name, data: data }) + ); + } + }, { + key: "renderLabel", + value: function renderLabel(data) { + if (this.props.label) { + return React.createElement( + "label", + { htmlFor: this.props.id }, + this.props.label + ); + } + } + }]); + return TextArea; +}(Component); + + +TextArea.defaultProps = { + name: 'textarea', + id: 'textarea', + className: 'form-control', + onChangeValue: function onChangeValue(text) {} +}; + +export { CheckBox, Form, Input, Option, OptionGroup, RadioGroup, Radio, Submit, TextArea }; +//# sourceMappingURL=index.es.js.map diff --git a/dist/index.es.js.map b/dist/index.es.js.map new file mode 100644 index 0000000..f396079 --- /dev/null +++ b/dist/index.es.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.es.js","sources":["../src/FormContext.js","../src/FormItemError.js","../src/CheckBox.js","../node_modules/classnames/index.js","../node_modules/react-lifecycles-compat/react-lifecycles-compat.es.js","../node_modules/react-transition-group/utils/ChildMapping.js","../node_modules/react-transition-group/TransitionGroup.js","../node_modules/react-toastify/lib/utils/constant.js","../node_modules/react-toastify/lib/utils/propValidator.js","../node_modules/react-toastify/lib/components/ProgressBar.js","../node_modules/react-toastify/lib/components/Toast.js","../node_modules/react-toastify/lib/components/CloseButton.js","../node_modules/react-transition-group/utils/PropTypes.js","../node_modules/react-transition-group/Transition.js","../node_modules/react-toastify/lib/utils/cssTransition.js","../node_modules/react-toastify/lib/components/Transitions.js","../node_modules/react-toastify/lib/utils/eventManager.js","../node_modules/react-toastify/lib/components/ToastContainer.js","../node_modules/react-toastify/lib/toast.js","../node_modules/react-toastify/lib/index.js","../src/Form.js","../src/Input.js","../src/OptionGroup.js","../src/Option.js","../src/RadioGroup.js","../src/Radio.js","../src/Submit.js","../src/TextArea.js"],"sourcesContent":["import React, { Component } from 'react'\n\nconst FormContext = React.createContext({ data: null });\n\nexport default FormContext\n\nexport class FormConsumer extends Component\n{\n render()\n {\n return (\n \n {(props) => this.props.children(props)}\n \n )\n }\n}","import React, {Component} from 'react';\n\nexport default class FormItemError extends Component\n{\n render() {\n const data = this.props.data\n\n if (!data || !data.errors || !data.errors[this.props.name]) return null\n\n return (\n

{data.errors[this.props.name].error}

\n )\n }\n}","import React, {Component} from 'react';\nimport {FormConsumer} from \"./FormContext\";\nimport FormItemError from \"./FormItemError\";\n\nexport default class CheckBox extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderCheckBox(data)}\n \n )\n }\n\n renderCheckBox(data)\n {\n let props = {...this.props}\n if (props.children) delete props.children\n if (props.onChangeValue) delete props.onChangeValue\n return (\n
\n this.props.onChangeValue(e.target.checked)}\n {...props} />\n {this.renderLabel(data)}\n \n
\n )\n }\n\n renderLabel(data)\n {\n if (this.props.children.length) {\n return (\n \n )\n }\n }\n}\n\nCheckBox.defaultProps = {\n name: 'checkbox',\n id: 'checkbox',\n className: 'form-check-input',\n onChangeValue: (checked) => {}\n}","/*!\n Copyright (c) 2017 Jed Watson.\n Licensed under the MIT License (MIT), see\n http://jedwatson.github.io/classnames\n*/\n/* global define */\n\n(function () {\n\t'use strict';\n\n\tvar hasOwn = {}.hasOwnProperty;\n\n\tfunction classNames () {\n\t\tvar classes = [];\n\n\t\tfor (var i = 0; i < arguments.length; i++) {\n\t\t\tvar arg = arguments[i];\n\t\t\tif (!arg) continue;\n\n\t\t\tvar argType = typeof arg;\n\n\t\t\tif (argType === 'string' || argType === 'number') {\n\t\t\t\tclasses.push(arg);\n\t\t\t} else if (Array.isArray(arg) && arg.length) {\n\t\t\t\tvar inner = classNames.apply(null, arg);\n\t\t\t\tif (inner) {\n\t\t\t\t\tclasses.push(inner);\n\t\t\t\t}\n\t\t\t} else if (argType === 'object') {\n\t\t\t\tfor (var key in arg) {\n\t\t\t\t\tif (hasOwn.call(arg, key) && arg[key]) {\n\t\t\t\t\t\tclasses.push(key);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn classes.join(' ');\n\t}\n\n\tif (typeof module !== 'undefined' && module.exports) {\n\t\tclassNames.default = classNames;\n\t\tmodule.exports = classNames;\n\t} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {\n\t\t// register as 'classnames', consistent with npm package name\n\t\tdefine('classnames', [], function () {\n\t\t\treturn classNames;\n\t\t});\n\t} else {\n\t\twindow.classNames = classNames;\n\t}\n}());\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nfunction componentWillMount() {\n // Call this.constructor.gDSFP to support sub-classes.\n var state = this.constructor.getDerivedStateFromProps(this.props, this.state);\n if (state !== null && state !== undefined) {\n this.setState(state);\n }\n}\n\nfunction componentWillReceiveProps(nextProps) {\n // Call this.constructor.gDSFP to support sub-classes.\n // Use the setState() updater to ensure state isn't stale in certain edge cases.\n function updater(prevState) {\n var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);\n return state !== null && state !== undefined ? state : null;\n }\n // Binding \"this\" is important for shallow renderer support.\n this.setState(updater.bind(this));\n}\n\nfunction componentWillUpdate(nextProps, nextState) {\n try {\n var prevProps = this.props;\n var prevState = this.state;\n this.props = nextProps;\n this.state = nextState;\n this.__reactInternalSnapshotFlag = true;\n this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate(\n prevProps,\n prevState\n );\n } finally {\n this.props = prevProps;\n this.state = prevState;\n }\n}\n\n// React may warn about cWM/cWRP/cWU methods being deprecated.\n// Add a flag to suppress these warnings for this special case.\ncomponentWillMount.__suppressDeprecationWarning = true;\ncomponentWillReceiveProps.__suppressDeprecationWarning = true;\ncomponentWillUpdate.__suppressDeprecationWarning = true;\n\nfunction polyfill(Component) {\n var prototype = Component.prototype;\n\n if (!prototype || !prototype.isReactComponent) {\n throw new Error('Can only polyfill class components');\n }\n\n if (\n typeof Component.getDerivedStateFromProps !== 'function' &&\n typeof prototype.getSnapshotBeforeUpdate !== 'function'\n ) {\n return Component;\n }\n\n // If new component APIs are defined, \"unsafe\" lifecycles won't be called.\n // Error if any of these lifecycles are present,\n // Because they would work differently between older and newer (16.3+) versions of React.\n var foundWillMountName = null;\n var foundWillReceivePropsName = null;\n var foundWillUpdateName = null;\n if (typeof prototype.componentWillMount === 'function') {\n foundWillMountName = 'componentWillMount';\n } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {\n foundWillMountName = 'UNSAFE_componentWillMount';\n }\n if (typeof prototype.componentWillReceiveProps === 'function') {\n foundWillReceivePropsName = 'componentWillReceiveProps';\n } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {\n foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';\n }\n if (typeof prototype.componentWillUpdate === 'function') {\n foundWillUpdateName = 'componentWillUpdate';\n } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {\n foundWillUpdateName = 'UNSAFE_componentWillUpdate';\n }\n if (\n foundWillMountName !== null ||\n foundWillReceivePropsName !== null ||\n foundWillUpdateName !== null\n ) {\n var componentName = Component.displayName || Component.name;\n var newApiName =\n typeof Component.getDerivedStateFromProps === 'function'\n ? 'getDerivedStateFromProps()'\n : 'getSnapshotBeforeUpdate()';\n\n throw Error(\n 'Unsafe legacy lifecycles will not be called for components using new component APIs.\\n\\n' +\n componentName +\n ' uses ' +\n newApiName +\n ' but also contains the following legacy lifecycles:' +\n (foundWillMountName !== null ? '\\n ' + foundWillMountName : '') +\n (foundWillReceivePropsName !== null\n ? '\\n ' + foundWillReceivePropsName\n : '') +\n (foundWillUpdateName !== null ? '\\n ' + foundWillUpdateName : '') +\n '\\n\\nThe above lifecycles should be removed. Learn more about this warning here:\\n' +\n 'https://fb.me/react-async-component-lifecycle-hooks'\n );\n }\n\n // React <= 16.2 does not support static getDerivedStateFromProps.\n // As a workaround, use cWM and cWRP to invoke the new static lifecycle.\n // Newer versions of React will ignore these lifecycles if gDSFP exists.\n if (typeof Component.getDerivedStateFromProps === 'function') {\n prototype.componentWillMount = componentWillMount;\n prototype.componentWillReceiveProps = componentWillReceiveProps;\n }\n\n // React <= 16.2 does not support getSnapshotBeforeUpdate.\n // As a workaround, use cWU to invoke the new lifecycle.\n // Newer versions of React will ignore that lifecycle if gSBU exists.\n if (typeof prototype.getSnapshotBeforeUpdate === 'function') {\n if (typeof prototype.componentDidUpdate !== 'function') {\n throw new Error(\n 'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'\n );\n }\n\n prototype.componentWillUpdate = componentWillUpdate;\n\n var componentDidUpdate = prototype.componentDidUpdate;\n\n prototype.componentDidUpdate = function componentDidUpdatePolyfill(\n prevProps,\n prevState,\n maybeSnapshot\n ) {\n // 16.3+ will not execute our will-update method;\n // It will pass a snapshot value to did-update though.\n // Older versions will require our polyfilled will-update value.\n // We need to handle both cases, but can't just check for the presence of \"maybeSnapshot\",\n // Because for <= 15.x versions this might be a \"prevContext\" object.\n // We also can't just check \"__reactInternalSnapshot\",\n // Because get-snapshot might return a falsy value.\n // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.\n var snapshot = this.__reactInternalSnapshotFlag\n ? this.__reactInternalSnapshot\n : maybeSnapshot;\n\n componentDidUpdate.call(this, prevProps, prevState, snapshot);\n };\n }\n\n return Component;\n}\n\nexport { polyfill };\n","\"use strict\";\n\nexports.__esModule = true;\nexports.getChildMapping = getChildMapping;\nexports.mergeChildMappings = mergeChildMappings;\nexports.getInitialChildMapping = getInitialChildMapping;\nexports.getNextChildMapping = getNextChildMapping;\n\nvar _react = require(\"react\");\n\n/**\n * Given `this.props.children`, return an object mapping key to child.\n *\n * @param {*} children `this.props.children`\n * @return {object} Mapping of key to child\n */\nfunction getChildMapping(children, mapFn) {\n var mapper = function mapper(child) {\n return mapFn && (0, _react.isValidElement)(child) ? mapFn(child) : child;\n };\n\n var result = Object.create(null);\n if (children) _react.Children.map(children, function (c) {\n return c;\n }).forEach(function (child) {\n // run the map function here instead so that the key is the computed one\n result[child.key] = mapper(child);\n });\n return result;\n}\n/**\n * When you're adding or removing children some may be added or removed in the\n * same render pass. We want to show *both* since we want to simultaneously\n * animate elements in and out. This function takes a previous set of keys\n * and a new set of keys and merges them with its best guess of the correct\n * ordering. In the future we may expose some of the utilities in\n * ReactMultiChild to make this easy, but for now React itself does not\n * directly have this concept of the union of prevChildren and nextChildren\n * so we implement it here.\n *\n * @param {object} prev prev children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @param {object} next next children as returned from\n * `ReactTransitionChildMapping.getChildMapping()`.\n * @return {object} a key set that contains all keys in `prev` and all keys\n * in `next` in a reasonable order.\n */\n\n\nfunction mergeChildMappings(prev, next) {\n prev = prev || {};\n next = next || {};\n\n function getValueForKey(key) {\n return key in next ? next[key] : prev[key];\n } // For each key of `next`, the list of keys to insert before that key in\n // the combined list\n\n\n var nextKeysPending = Object.create(null);\n var pendingKeys = [];\n\n for (var prevKey in prev) {\n if (prevKey in next) {\n if (pendingKeys.length) {\n nextKeysPending[prevKey] = pendingKeys;\n pendingKeys = [];\n }\n } else {\n pendingKeys.push(prevKey);\n }\n }\n\n var i;\n var childMapping = {};\n\n for (var nextKey in next) {\n if (nextKeysPending[nextKey]) {\n for (i = 0; i < nextKeysPending[nextKey].length; i++) {\n var pendingNextKey = nextKeysPending[nextKey][i];\n childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);\n }\n }\n\n childMapping[nextKey] = getValueForKey(nextKey);\n } // Finally, add the keys which didn't appear before any key in `next`\n\n\n for (i = 0; i < pendingKeys.length; i++) {\n childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);\n }\n\n return childMapping;\n}\n\nfunction getProp(child, prop, props) {\n return props[prop] != null ? props[prop] : child.props[prop];\n}\n\nfunction getInitialChildMapping(props, onExited) {\n return getChildMapping(props.children, function (child) {\n return (0, _react.cloneElement)(child, {\n onExited: onExited.bind(null, child),\n in: true,\n appear: getProp(child, 'appear', props),\n enter: getProp(child, 'enter', props),\n exit: getProp(child, 'exit', props)\n });\n });\n}\n\nfunction getNextChildMapping(nextProps, prevChildMapping, onExited) {\n var nextChildMapping = getChildMapping(nextProps.children);\n var children = mergeChildMappings(prevChildMapping, nextChildMapping);\n Object.keys(children).forEach(function (key) {\n var child = children[key];\n if (!(0, _react.isValidElement)(child)) return;\n var hasPrev = key in prevChildMapping;\n var hasNext = key in nextChildMapping;\n var prevChild = prevChildMapping[key];\n var isLeaving = (0, _react.isValidElement)(prevChild) && !prevChild.props.in; // item is new (entering)\n\n if (hasNext && (!hasPrev || isLeaving)) {\n // console.log('entering', key)\n children[key] = (0, _react.cloneElement)(child, {\n onExited: onExited.bind(null, child),\n in: true,\n exit: getProp(child, 'exit', nextProps),\n enter: getProp(child, 'enter', nextProps)\n });\n } else if (!hasNext && hasPrev && !isLeaving) {\n // item is old (exiting)\n // console.log('leaving', key)\n children[key] = (0, _react.cloneElement)(child, {\n in: false\n });\n } else if (hasNext && hasPrev && (0, _react.isValidElement)(prevChild)) {\n // item hasn't changed transition states\n // copy over the last transition props;\n // console.log('unchanged', key)\n children[key] = (0, _react.cloneElement)(child, {\n onExited: onExited.bind(null, child),\n in: prevChild.props.in,\n exit: getProp(child, 'exit', nextProps),\n enter: getProp(child, 'enter', nextProps)\n });\n }\n });\n return children;\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _reactLifecyclesCompat = require(\"react-lifecycles-compat\");\n\nvar _ChildMapping = require(\"./utils/ChildMapping\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _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; }\n\nfunction _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); }\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nvar values = Object.values || function (obj) {\n return Object.keys(obj).map(function (k) {\n return obj[k];\n });\n};\n\nvar defaultProps = {\n component: 'div',\n childFactory: function childFactory(child) {\n return child;\n }\n /**\n * The `` component manages a set of transition components\n * (`` and ``) in a list. Like with the transition\n * components, `` is a state machine for managing the mounting\n * and unmounting of components over time.\n *\n * Consider the example below. As items are removed or added to the TodoList the\n * `in` prop is toggled automatically by the ``.\n *\n * Note that `` does not define any animation behavior!\n * Exactly _how_ a list item animates is up to the individual transition\n * component. This means you can mix and match animations across different list\n * items.\n */\n\n};\n\nvar TransitionGroup =\n/*#__PURE__*/\nfunction (_React$Component) {\n _inheritsLoose(TransitionGroup, _React$Component);\n\n function TransitionGroup(props, context) {\n var _this;\n\n _this = _React$Component.call(this, props, context) || this;\n\n var handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this))); // Initial children should all be entering, dependent on appear\n\n\n _this.state = {\n handleExited: handleExited,\n firstRender: true\n };\n return _this;\n }\n\n var _proto = TransitionGroup.prototype;\n\n _proto.getChildContext = function getChildContext() {\n return {\n transitionGroup: {\n isMounting: !this.appeared\n }\n };\n };\n\n _proto.componentDidMount = function componentDidMount() {\n this.appeared = true;\n this.mounted = true;\n };\n\n _proto.componentWillUnmount = function componentWillUnmount() {\n this.mounted = false;\n };\n\n TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {\n var prevChildMapping = _ref.children,\n handleExited = _ref.handleExited,\n firstRender = _ref.firstRender;\n return {\n children: firstRender ? (0, _ChildMapping.getInitialChildMapping)(nextProps, handleExited) : (0, _ChildMapping.getNextChildMapping)(nextProps, prevChildMapping, handleExited),\n firstRender: false\n };\n };\n\n _proto.handleExited = function handleExited(child, node) {\n var currentChildMapping = (0, _ChildMapping.getChildMapping)(this.props.children);\n if (child.key in currentChildMapping) return;\n\n if (child.props.onExited) {\n child.props.onExited(node);\n }\n\n if (this.mounted) {\n this.setState(function (state) {\n var children = _extends({}, state.children);\n\n delete children[child.key];\n return {\n children: children\n };\n });\n }\n };\n\n _proto.render = function render() {\n var _this$props = this.props,\n Component = _this$props.component,\n childFactory = _this$props.childFactory,\n props = _objectWithoutPropertiesLoose(_this$props, [\"component\", \"childFactory\"]);\n\n var children = values(this.state.children).map(childFactory);\n delete props.appear;\n delete props.enter;\n delete props.exit;\n\n if (Component === null) {\n return children;\n }\n\n return _react.default.createElement(Component, props, children);\n };\n\n return TransitionGroup;\n}(_react.default.Component);\n\nTransitionGroup.childContextTypes = {\n transitionGroup: _propTypes.default.object.isRequired\n};\nTransitionGroup.propTypes = process.env.NODE_ENV !== \"production\" ? {\n /**\n * `` renders a `
` by default. You can change this\n * behavior by providing a `component` prop.\n * If you use React v16+ and would like to avoid a wrapping `
` element\n * you can pass in `component={null}`. This is useful if the wrapping div\n * borks your css styles.\n */\n component: _propTypes.default.any,\n\n /**\n * A set of `` components, that are toggled `in` and out as they\n * leave. the `` will inject specific transition props, so\n * remember to spread them through if you are wrapping the `` as\n * with our `` example.\n */\n children: _propTypes.default.node,\n\n /**\n * A convenience prop that enables or disables appear animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n appear: _propTypes.default.bool,\n\n /**\n * A convenience prop that enables or disables enter animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n enter: _propTypes.default.bool,\n\n /**\n * A convenience prop that enables or disables exit animations\n * for all children. Note that specifying this will override any defaults set\n * on individual children Transitions.\n */\n exit: _propTypes.default.bool,\n\n /**\n * You may need to apply reactive updates to a child as it is exiting.\n * This is generally done by using `cloneElement` however in the case of an exiting\n * child the element has already been removed and not accessible to the consumer.\n *\n * If you do need to update a child as it leaves you can provide a `childFactory`\n * to wrap every child, even the ones that are leaving.\n *\n * @type Function(child: ReactElement) -> ReactElement\n */\n childFactory: _propTypes.default.func\n} : {};\nTransitionGroup.defaultProps = defaultProps;\n\nvar _default = (0, _reactLifecyclesCompat.polyfill)(TransitionGroup);\n\nexports.default = _default;\nmodule.exports = exports[\"default\"];","\"use strict\";\n\nexports.__esModule = true;\nexports.ACTION = exports.TYPE = exports.POSITION = void 0;\nvar POSITION = {\n TOP_LEFT: 'top-left',\n TOP_RIGHT: 'top-right',\n TOP_CENTER: 'top-center',\n BOTTOM_LEFT: 'bottom-left',\n BOTTOM_RIGHT: 'bottom-right',\n BOTTOM_CENTER: 'bottom-center'\n};\nexports.POSITION = POSITION;\nvar TYPE = {\n INFO: 'info',\n SUCCESS: 'success',\n WARNING: 'warning',\n ERROR: 'error',\n DEFAULT: 'default'\n};\nexports.TYPE = TYPE;\nvar ACTION = {\n SHOW: 0,\n CLEAR: 1,\n DID_MOUNT: 2,\n WILL_UNMOUNT: 3,\n ON_CHANGE: 4\n};\nexports.ACTION = ACTION;","\"use strict\";\n\nexports.__esModule = true;\nexports.isValidDelay = isValidDelay;\nexports.objectValues = objectValues;\nexports.falseOrElement = exports.falseOrDelay = void 0;\n\nvar _react = require(\"react\");\n\nfunction isValidDelay(val) {\n return typeof val === 'number' && !isNaN(val) && val > 0;\n}\n\nfunction objectValues(obj) {\n return Object.keys(obj).map(function (key) {\n return obj[key];\n });\n}\n\nfunction withRequired(fn) {\n fn.isRequired = function (props, propName, componentName) {\n var prop = props[propName];\n\n if (typeof prop === 'undefined') {\n return new Error(\"The prop \" + propName + \" is marked as required in \\n \" + componentName + \", but its value is undefined.\");\n }\n\n fn(props, propName, componentName);\n };\n\n return fn;\n}\n\nvar falseOrDelay = withRequired(function (props, propName, componentName) {\n var prop = props[propName];\n\n if (prop !== false && !isValidDelay(prop)) {\n return new Error(componentName + \" expect \" + propName + \" \\n to be a valid Number > 0 or equal to false. \" + prop + \" given.\");\n }\n\n return null;\n});\nexports.falseOrDelay = falseOrDelay;\nvar falseOrElement = withRequired(function (props, propName, componentName) {\n var prop = props[propName];\n\n if (prop !== false && !(0, _react.isValidElement)(prop)) {\n return new Error(componentName + \" expect \" + propName + \" \\n to be a valid react element or equal to false. \" + prop + \" given.\");\n }\n\n return null;\n});\nexports.falseOrElement = falseOrElement;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _classnames = _interopRequireDefault(require(\"classnames\"));\n\nvar _constant = require(\"./../utils/constant\");\n\nvar _propValidator = require(\"../utils/propValidator\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _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); }\n\nfunction ProgressBar(_ref) {\n var _animationEvent;\n\n var delay = _ref.delay,\n isRunning = _ref.isRunning,\n closeToast = _ref.closeToast,\n type = _ref.type,\n hide = _ref.hide,\n className = _ref.className,\n userStyle = _ref.style,\n controlledProgress = _ref.controlledProgress,\n progress = _ref.progress,\n isProgressDone = _ref.isProgressDone,\n rtl = _ref.rtl;\n\n var style = _extends({}, userStyle, {\n animationDuration: delay + \"ms\",\n animationPlayState: isRunning ? 'running' : 'paused',\n opacity: hide ? 0 : 1,\n transform: controlledProgress ? \"scaleX(\" + progress + \")\" : null\n });\n\n var classNames = (0, _classnames.default)('Toastify__progress-bar', controlledProgress ? 'Toastify__progress-bar--controlled' : 'Toastify__progress-bar--animated', \"Toastify__progress-bar--\" + type, {\n 'Toastify__progress-bar--rtl': rtl\n }, className);\n var animationEvent = (_animationEvent = {}, _animationEvent[controlledProgress && isProgressDone ? 'onTransitionEnd' : 'onAnimationEnd'] = controlledProgress && !isProgressDone ? null : closeToast, _animationEvent);\n return _react.default.createElement(\"div\", _extends({\n className: classNames,\n style: style\n }, animationEvent));\n}\n\nProgressBar.propTypes = {\n /**\n * The animation delay which determine when to close the toast\n */\n delay: _propValidator.falseOrDelay.isRequired,\n\n /**\n * Whether or not the animation is running or paused\n */\n isRunning: _propTypes.default.bool.isRequired,\n\n /**\n * Func to close the current toast\n */\n closeToast: _propTypes.default.func.isRequired,\n\n /**\n * Support rtl content\n */\n rtl: _propTypes.default.bool.isRequired,\n\n /**\n * Optional type : info, success ...\n */\n type: _propTypes.default.string,\n\n /**\n * Hide or not the progress bar\n */\n hide: _propTypes.default.bool,\n\n /**\n * Optionnal className\n */\n className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n\n /**\n * Controlled progress value\n */\n progress: _propTypes.default.number,\n\n /**\n * Tell wether or not controlled progress bar is used\n */\n controlledProgress: _propTypes.default.bool,\n\n /**\n * Helper to close the toast when using controlled progress value\n */\n isProgressDone: _propTypes.default.bool\n};\nProgressBar.defaultProps = {\n type: _constant.TYPE.DEFAULT,\n hide: false\n};\nvar _default = ProgressBar;\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _react = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _classnames = _interopRequireDefault(require(\"classnames\"));\n\nvar _ProgressBar = _interopRequireDefault(require(\"./ProgressBar\"));\n\nvar _constant = require(\"./../utils/constant\");\n\nvar _propValidator = require(\"./../utils/propValidator\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }\n\nfunction _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); }\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nfunction getX(e) {\n return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientX : e.clientX;\n}\n\nfunction getY(e) {\n return e.targetTouches && e.targetTouches.length >= 1 ? e.targetTouches[0].clientY : e.clientY;\n}\n\nvar noop = function noop() {};\n\nvar Toast =\n/*#__PURE__*/\nfunction (_Component) {\n _inheritsLoose(Toast, _Component);\n\n function Toast() {\n var _this;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n _this = _Component.call.apply(_Component, [this].concat(args)) || this;\n _this.state = {\n isRunning: true,\n preventExitTransition: false\n };\n _this.flag = {\n canCloseOnClick: true,\n canDrag: false\n };\n _this.drag = {\n start: 0,\n x: 0,\n y: 0,\n deltaX: 0,\n removalDistance: 0\n };\n _this.ref = null;\n\n _this.pauseToast = function () {\n if (_this.props.autoClose) {\n _this.setState({\n isRunning: false\n });\n }\n };\n\n _this.playToast = function () {\n if (_this.props.autoClose) {\n _this.setState({\n isRunning: true\n });\n }\n };\n\n _this.onDragStart = function (e) {\n _this.flag.canCloseOnClick = true;\n _this.flag.canDrag = true;\n _this.ref.style.transition = '';\n _this.drag.start = _this.drag.x = getX(e.nativeEvent);\n _this.drag.removalDistance = _this.ref.offsetWidth * (_this.props.draggablePercent / 100);\n };\n\n _this.onDragMove = function (e) {\n if (_this.flag.canDrag) {\n if (_this.state.isRunning) {\n _this.pauseToast();\n }\n\n _this.drag.x = getX(e);\n _this.drag.deltaX = _this.drag.x - _this.drag.start; // prevent false positif during a toast click\n\n _this.drag.start !== _this.drag.x && (_this.flag.canCloseOnClick = false);\n _this.ref.style.transform = \"translateX(\" + _this.drag.deltaX + \"px)\";\n _this.ref.style.opacity = 1 - Math.abs(_this.drag.deltaX / _this.drag.removalDistance);\n }\n };\n\n _this.onDragEnd = function (e) {\n if (_this.flag.canDrag) {\n _this.flag.canDrag = false;\n\n if (Math.abs(_this.drag.deltaX) > _this.drag.removalDistance) {\n _this.setState({\n preventExitTransition: true\n }, _this.props.closeToast);\n\n return;\n }\n\n _this.drag.y = getY(e);\n _this.ref.style.transition = 'transform 0.2s, opacity 0.2s';\n _this.ref.style.transform = 'translateX(0)';\n _this.ref.style.opacity = 1;\n }\n };\n\n _this.onDragTransitionEnd = function () {\n var _this$ref$getBounding = _this.ref.getBoundingClientRect(),\n top = _this$ref$getBounding.top,\n bottom = _this$ref$getBounding.bottom,\n left = _this$ref$getBounding.left,\n right = _this$ref$getBounding.right;\n\n if (_this.props.pauseOnHover && _this.drag.x >= left && _this.drag.x <= right && _this.drag.y >= top && _this.drag.y <= bottom) {\n _this.pauseToast();\n } else {\n _this.playToast();\n }\n };\n\n return _this;\n }\n\n var _proto = Toast.prototype;\n\n _proto.componentDidMount = function componentDidMount() {\n this.props.onOpen(this.props.children.props);\n\n if (this.props.draggable) {\n this.bindDragEvents();\n } // Maybe I could bind the event in the ToastContainer and rely on delegation\n\n\n if (this.props.pauseOnFocusLoss) {\n this.bindFocusEvents();\n }\n };\n\n _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n if (prevProps.draggable !== this.props.draggable) {\n if (this.props.draggable) {\n this.bindDragEvents();\n } else {\n this.unbindDragEvents();\n }\n }\n\n if (prevProps.pauseOnFocusLoss !== this.props.pauseOnFocusLoss) {\n if (this.props.pauseOnFocusLoss) {\n this.bindFocusEvents();\n } else {\n this.unbindFocusEvents();\n }\n }\n };\n\n _proto.componentWillUnmount = function componentWillUnmount() {\n this.props.onClose(this.props.children.props);\n\n if (this.props.draggable) {\n this.unbindDragEvents();\n }\n\n if (this.props.pauseOnFocusLoss) {\n this.unbindFocusEvents();\n }\n };\n\n _proto.bindFocusEvents = function bindFocusEvents() {\n window.addEventListener('focus', this.playToast);\n window.addEventListener('blur', this.pauseToast);\n };\n\n _proto.unbindFocusEvents = function unbindFocusEvents() {\n window.removeEventListener('focus', this.playToast);\n window.removeEventListener('blur', this.pauseToast);\n };\n\n _proto.bindDragEvents = function bindDragEvents() {\n document.addEventListener('mousemove', this.onDragMove);\n document.addEventListener('mouseup', this.onDragEnd);\n document.addEventListener('touchmove', this.onDragMove);\n document.addEventListener('touchend', this.onDragEnd);\n };\n\n _proto.unbindDragEvents = function unbindDragEvents() {\n document.removeEventListener('mousemove', this.onDragMove);\n document.removeEventListener('mouseup', this.onDragEnd);\n document.removeEventListener('touchmove', this.onDragMove);\n document.removeEventListener('touchend', this.onDragEnd);\n };\n\n _proto.render = function render() {\n var _this2 = this;\n\n var _this$props = this.props,\n closeButton = _this$props.closeButton,\n children = _this$props.children,\n autoClose = _this$props.autoClose,\n pauseOnHover = _this$props.pauseOnHover,\n closeOnClick = _this$props.closeOnClick,\n type = _this$props.type,\n hideProgressBar = _this$props.hideProgressBar,\n closeToast = _this$props.closeToast,\n Transition = _this$props.transition,\n position = _this$props.position,\n onExited = _this$props.onExited,\n className = _this$props.className,\n bodyClassName = _this$props.bodyClassName,\n progressClassName = _this$props.progressClassName,\n progressStyle = _this$props.progressStyle,\n updateId = _this$props.updateId,\n role = _this$props.role,\n progress = _this$props.progress,\n isProgressDone = _this$props.isProgressDone,\n rtl = _this$props.rtl;\n var toastProps = {\n className: (0, _classnames.default)('Toastify__toast', \"Toastify__toast--\" + type, {\n 'Toastify__toast--rtl': rtl\n }, className)\n };\n\n if (autoClose && pauseOnHover) {\n toastProps.onMouseEnter = this.pauseToast;\n toastProps.onMouseLeave = this.playToast;\n } // prevent toast from closing when user drags the toast\n\n\n if (closeOnClick) {\n toastProps.onClick = function () {\n return _this2.flag.canCloseOnClick && closeToast();\n };\n }\n\n var controlledProgress = parseFloat(progress) === progress;\n return _react.default.createElement(Transition, {\n in: this.props.in,\n appear: true,\n unmountOnExit: true,\n onExited: onExited,\n position: position,\n preventExitTransition: this.state.preventExitTransition\n }, _react.default.createElement(\"div\", _extends({}, toastProps, {\n ref: function ref(_ref) {\n return _this2.ref = _ref;\n },\n onMouseDown: this.onDragStart,\n onTouchStart: this.onDragStart,\n onTransitionEnd: this.onDragTransitionEnd\n }), _react.default.createElement(\"div\", _extends({}, this.props.in && {\n role: role\n }, {\n className: (0, _classnames.default)('Toastify__toast-body', bodyClassName)\n }), children), closeButton && closeButton, (autoClose || controlledProgress) && _react.default.createElement(_ProgressBar.default, _extends({}, updateId && !controlledProgress ? {\n key: \"pb-\" + updateId\n } : {}, {\n rtl: rtl,\n delay: autoClose,\n isRunning: this.state.isRunning,\n closeToast: closeToast,\n hide: hideProgressBar,\n type: type,\n style: progressStyle,\n className: progressClassName,\n controlledProgress: controlledProgress,\n isProgressDone: isProgressDone,\n progress: progress\n }))));\n };\n\n return Toast;\n}(_react.Component);\n\nToast.propTypes = {\n closeButton: _propValidator.falseOrElement.isRequired,\n autoClose: _propValidator.falseOrDelay.isRequired,\n children: _propTypes.default.node.isRequired,\n closeToast: _propTypes.default.func.isRequired,\n position: _propTypes.default.oneOf((0, _propValidator.objectValues)(_constant.POSITION)).isRequired,\n pauseOnHover: _propTypes.default.bool.isRequired,\n pauseOnFocusLoss: _propTypes.default.bool.isRequired,\n closeOnClick: _propTypes.default.bool.isRequired,\n transition: _propTypes.default.func.isRequired,\n rtl: _propTypes.default.bool.isRequired,\n hideProgressBar: _propTypes.default.bool.isRequired,\n draggable: _propTypes.default.bool.isRequired,\n draggablePercent: _propTypes.default.number.isRequired,\n in: _propTypes.default.bool,\n onExited: _propTypes.default.func,\n onOpen: _propTypes.default.func,\n onClose: _propTypes.default.func,\n type: _propTypes.default.oneOf((0, _propValidator.objectValues)(_constant.TYPE)),\n className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n bodyClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n progressClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n progressStyle: _propTypes.default.object,\n progress: _propTypes.default.number,\n isProgressDone: _propTypes.default.bool,\n updateId: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),\n ariaLabel: _propTypes.default.string\n};\nToast.defaultProps = {\n type: _constant.TYPE.DEFAULT,\n in: true,\n onOpen: noop,\n onClose: noop,\n className: null,\n bodyClassName: null,\n progressClassName: null,\n updateId: null,\n role: 'alert'\n};\nvar _default = Toast;\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction CloseButton(_ref) {\n var closeToast = _ref.closeToast,\n type = _ref.type,\n ariaLabel = _ref.ariaLabel;\n return _react.default.createElement(\"button\", {\n className: \"Toastify__close-button Toastify__close-button--\" + type,\n type: \"button\",\n onClick: closeToast,\n \"aria-label\": ariaLabel\n }, \"\\u2716\");\n}\n\nCloseButton.propTypes = {\n closeToast: _propTypes.default.func,\n arialLabel: _propTypes.default.string\n};\nCloseButton.defaultProps = {\n ariaLabel: 'close'\n};\nvar _default = CloseButton;\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\nexports.classNamesShape = exports.timeoutsShape = void 0;\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar timeoutsShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({\n enter: _propTypes.default.number,\n exit: _propTypes.default.number,\n appear: _propTypes.default.number\n}).isRequired]) : null;\nexports.timeoutsShape = timeoutsShape;\nvar classNamesShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.shape({\n enter: _propTypes.default.string,\n exit: _propTypes.default.string,\n active: _propTypes.default.string\n}), _propTypes.default.shape({\n enter: _propTypes.default.string,\n enterDone: _propTypes.default.string,\n enterActive: _propTypes.default.string,\n exit: _propTypes.default.string,\n exitDone: _propTypes.default.string,\n exitActive: _propTypes.default.string\n})]) : null;\nexports.classNamesShape = classNamesShape;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = void 0;\n\nvar PropTypes = _interopRequireWildcard(require(\"prop-types\"));\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _reactLifecyclesCompat = require(\"react-lifecycles-compat\");\n\nvar _PropTypes = require(\"./utils/PropTypes\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }\n\nfunction _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; }\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar UNMOUNTED = 'unmounted';\nexports.UNMOUNTED = UNMOUNTED;\nvar EXITED = 'exited';\nexports.EXITED = EXITED;\nvar ENTERING = 'entering';\nexports.ENTERING = ENTERING;\nvar ENTERED = 'entered';\nexports.ENTERED = ENTERED;\nvar EXITING = 'exiting';\n/**\n * The Transition component lets you describe a transition from one component\n * state to another _over time_ with a simple declarative API. Most commonly\n * it's used to animate the mounting and unmounting of a component, but can also\n * be used to describe in-place transition states as well.\n *\n * By default the `Transition` component does not alter the behavior of the\n * component it renders, it only tracks \"enter\" and \"exit\" states for the components.\n * It's up to you to give meaning and effect to those states. For example we can\n * add styles to a component when it enters or exits:\n *\n * ```jsx\n * import Transition from 'react-transition-group/Transition';\n *\n * const duration = 300;\n *\n * const defaultStyle = {\n * transition: `opacity ${duration}ms ease-in-out`,\n * opacity: 0,\n * }\n *\n * const transitionStyles = {\n * entering: { opacity: 0 },\n * entered: { opacity: 1 },\n * };\n *\n * const Fade = ({ in: inProp }) => (\n * \n * {(state) => (\n *
\n * I'm a fade Transition!\n *
\n * )}\n * \n * );\n * ```\n *\n * As noted the `Transition` component doesn't _do_ anything by itself to its child component.\n * What it does do is track transition states over time so you can update the\n * component (such as by adding styles or classes) when it changes states.\n *\n * There are 4 main states a Transition can be in:\n * - `'entering'`\n * - `'entered'`\n * - `'exiting'`\n * - `'exited'`\n *\n * Transition state is toggled via the `in` prop. When `true` the component begins the\n * \"Enter\" stage. During this stage, the component will shift from its current transition state,\n * to `'entering'` for the duration of the transition and then to the `'entered'` stage once\n * it's complete. Let's take the following example:\n *\n * ```jsx\n * state = { in: false };\n *\n * toggleEnterState = () => {\n * this.setState({ in: true });\n * }\n *\n * render() {\n * return (\n *
\n * \n * \n *
\n * );\n * }\n * ```\n *\n * When the button is clicked the component will shift to the `'entering'` state and\n * stay there for 500ms (the value of `timeout`) before it finally switches to `'entered'`.\n *\n * When `in` is `false` the same thing happens except the state moves from `'exiting'` to `'exited'`.\n *\n * ## Timing\n *\n * Timing is often the trickiest part of animation, mistakes can result in slight delays\n * that are hard to pin down. A common example is when you want to add an exit transition,\n * you should set the desired final styles when the state is `'exiting'`. That's when the\n * transition to those styles will start and, if you matched the `timeout` prop with the\n * CSS Transition duration, it will end exactly when the state changes to `'exited'`.\n *\n * > **Note**: For simpler transitions the `Transition` component might be enough, but\n * > take into account that it's platform-agnostic, while the `CSSTransition` component\n * > [forces reflows](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)\n * > in order to make more complex transitions more predictable. For example, even though\n * > classes `example-enter` and `example-enter-active` are applied immediately one after\n * > another, you can still transition from one to the other because of the forced reflow\n * > (read [this issue](https://github.com/reactjs/react-transition-group/issues/159#issuecomment-322761171)\n * > for more info). Take this into account when choosing between `Transition` and\n * > `CSSTransition`.\n */\n\nexports.EXITING = EXITING;\n\nvar Transition =\n/*#__PURE__*/\nfunction (_React$Component) {\n _inheritsLoose(Transition, _React$Component);\n\n function Transition(props, context) {\n var _this;\n\n _this = _React$Component.call(this, props, context) || this;\n var parentGroup = context.transitionGroup; // In the context of a TransitionGroup all enters are really appears\n\n var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;\n var initialStatus;\n _this.appearStatus = null;\n\n if (props.in) {\n if (appear) {\n initialStatus = EXITED;\n _this.appearStatus = ENTERING;\n } else {\n initialStatus = ENTERED;\n }\n } else {\n if (props.unmountOnExit || props.mountOnEnter) {\n initialStatus = UNMOUNTED;\n } else {\n initialStatus = EXITED;\n }\n }\n\n _this.state = {\n status: initialStatus\n };\n _this.nextCallback = null;\n return _this;\n }\n\n var _proto = Transition.prototype;\n\n _proto.getChildContext = function getChildContext() {\n return {\n transitionGroup: null // allows for nested Transitions\n\n };\n };\n\n Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {\n var nextIn = _ref.in;\n\n if (nextIn && prevState.status === UNMOUNTED) {\n return {\n status: EXITED\n };\n }\n\n return null;\n }; // getSnapshotBeforeUpdate(prevProps) {\n // let nextStatus = null\n // if (prevProps !== this.props) {\n // const { status } = this.state\n // if (this.props.in) {\n // if (status !== ENTERING && status !== ENTERED) {\n // nextStatus = ENTERING\n // }\n // } else {\n // if (status === ENTERING || status === ENTERED) {\n // nextStatus = EXITING\n // }\n // }\n // }\n // return { nextStatus }\n // }\n\n\n _proto.componentDidMount = function componentDidMount() {\n this.updateStatus(true, this.appearStatus);\n };\n\n _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n var nextStatus = null;\n\n if (prevProps !== this.props) {\n var status = this.state.status;\n\n if (this.props.in) {\n if (status !== ENTERING && status !== ENTERED) {\n nextStatus = ENTERING;\n }\n } else {\n if (status === ENTERING || status === ENTERED) {\n nextStatus = EXITING;\n }\n }\n }\n\n this.updateStatus(false, nextStatus);\n };\n\n _proto.componentWillUnmount = function componentWillUnmount() {\n this.cancelNextCallback();\n };\n\n _proto.getTimeouts = function getTimeouts() {\n var timeout = this.props.timeout;\n var exit, enter, appear;\n exit = enter = appear = timeout;\n\n if (timeout != null && typeof timeout !== 'number') {\n exit = timeout.exit;\n enter = timeout.enter; // TODO: remove fallback for next major\n\n appear = timeout.appear !== undefined ? timeout.appear : enter;\n }\n\n return {\n exit: exit,\n enter: enter,\n appear: appear\n };\n };\n\n _proto.updateStatus = function updateStatus(mounting, nextStatus) {\n if (mounting === void 0) {\n mounting = false;\n }\n\n if (nextStatus !== null) {\n // nextStatus will always be ENTERING or EXITING.\n this.cancelNextCallback();\n\n var node = _reactDom.default.findDOMNode(this);\n\n if (nextStatus === ENTERING) {\n this.performEnter(node, mounting);\n } else {\n this.performExit(node);\n }\n } else if (this.props.unmountOnExit && this.state.status === EXITED) {\n this.setState({\n status: UNMOUNTED\n });\n }\n };\n\n _proto.performEnter = function performEnter(node, mounting) {\n var _this2 = this;\n\n var enter = this.props.enter;\n var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting;\n var timeouts = this.getTimeouts();\n var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED\n // if we are mounting and running this it means appear _must_ be set\n\n if (!mounting && !enter) {\n this.safeSetState({\n status: ENTERED\n }, function () {\n _this2.props.onEntered(node);\n });\n return;\n }\n\n this.props.onEnter(node, appearing);\n this.safeSetState({\n status: ENTERING\n }, function () {\n _this2.props.onEntering(node, appearing);\n\n _this2.onTransitionEnd(node, enterTimeout, function () {\n _this2.safeSetState({\n status: ENTERED\n }, function () {\n _this2.props.onEntered(node, appearing);\n });\n });\n });\n };\n\n _proto.performExit = function performExit(node) {\n var _this3 = this;\n\n var exit = this.props.exit;\n var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED\n\n if (!exit) {\n this.safeSetState({\n status: EXITED\n }, function () {\n _this3.props.onExited(node);\n });\n return;\n }\n\n this.props.onExit(node);\n this.safeSetState({\n status: EXITING\n }, function () {\n _this3.props.onExiting(node);\n\n _this3.onTransitionEnd(node, timeouts.exit, function () {\n _this3.safeSetState({\n status: EXITED\n }, function () {\n _this3.props.onExited(node);\n });\n });\n });\n };\n\n _proto.cancelNextCallback = function cancelNextCallback() {\n if (this.nextCallback !== null) {\n this.nextCallback.cancel();\n this.nextCallback = null;\n }\n };\n\n _proto.safeSetState = function safeSetState(nextState, callback) {\n // This shouldn't be necessary, but there are weird race conditions with\n // setState callbacks and unmounting in testing, so always make sure that\n // we can cancel any pending setState callbacks after we unmount.\n callback = this.setNextCallback(callback);\n this.setState(nextState, callback);\n };\n\n _proto.setNextCallback = function setNextCallback(callback) {\n var _this4 = this;\n\n var active = true;\n\n this.nextCallback = function (event) {\n if (active) {\n active = false;\n _this4.nextCallback = null;\n callback(event);\n }\n };\n\n this.nextCallback.cancel = function () {\n active = false;\n };\n\n return this.nextCallback;\n };\n\n _proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) {\n this.setNextCallback(handler);\n\n if (node) {\n if (this.props.addEndListener) {\n this.props.addEndListener(node, this.nextCallback);\n }\n\n if (timeout != null) {\n setTimeout(this.nextCallback, timeout);\n }\n } else {\n setTimeout(this.nextCallback, 0);\n }\n };\n\n _proto.render = function render() {\n var status = this.state.status;\n\n if (status === UNMOUNTED) {\n return null;\n }\n\n var _this$props = this.props,\n children = _this$props.children,\n childProps = _objectWithoutPropertiesLoose(_this$props, [\"children\"]); // filter props for Transtition\n\n\n delete childProps.in;\n delete childProps.mountOnEnter;\n delete childProps.unmountOnExit;\n delete childProps.appear;\n delete childProps.enter;\n delete childProps.exit;\n delete childProps.timeout;\n delete childProps.addEndListener;\n delete childProps.onEnter;\n delete childProps.onEntering;\n delete childProps.onEntered;\n delete childProps.onExit;\n delete childProps.onExiting;\n delete childProps.onExited;\n\n if (typeof children === 'function') {\n return children(status, childProps);\n }\n\n var child = _react.default.Children.only(children);\n\n return _react.default.cloneElement(child, childProps);\n };\n\n return Transition;\n}(_react.default.Component);\n\nTransition.contextTypes = {\n transitionGroup: PropTypes.object\n};\nTransition.childContextTypes = {\n transitionGroup: function transitionGroup() {}\n};\nTransition.propTypes = process.env.NODE_ENV !== \"production\" ? {\n /**\n * A `function` child can be used instead of a React element.\n * This function is called with the current transition status\n * ('entering', 'entered', 'exiting', 'exited', 'unmounted'), which can be used\n * to apply context specific props to a component.\n *\n * ```jsx\n * \n * {(status) => (\n * \n * )}\n * \n * ```\n */\n children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,\n\n /**\n * Show the component; triggers the enter or exit states\n */\n in: PropTypes.bool,\n\n /**\n * By default the child component is mounted immediately along with\n * the parent `Transition` component. If you want to \"lazy mount\" the component on the\n * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay\n * mounted, even on \"exited\", unless you also specify `unmountOnExit`.\n */\n mountOnEnter: PropTypes.bool,\n\n /**\n * By default the child component stays mounted after it reaches the `'exited'` state.\n * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.\n */\n unmountOnExit: PropTypes.bool,\n\n /**\n * Normally a component is not transitioned if it is shown when the `` component mounts.\n * If you want to transition on the first mount set `appear` to `true`, and the\n * component will transition in as soon as the `` mounts.\n *\n * > Note: there are no specific \"appear\" states. `appear` only adds an additional `enter` transition.\n */\n appear: PropTypes.bool,\n\n /**\n * Enable or disable enter transitions.\n */\n enter: PropTypes.bool,\n\n /**\n * Enable or disable exit transitions.\n */\n exit: PropTypes.bool,\n\n /**\n * The duration of the transition, in milliseconds.\n * Required unless `addEndListener` is provided\n *\n * You may specify a single timeout for all transitions like: `timeout={500}`,\n * or individually like:\n *\n * ```jsx\n * timeout={{\n * enter: 300,\n * exit: 500,\n * appear: 500,\n * }}\n * ```\n *\n * If the value of appear is not set, then the value from enter is taken.\n *\n * @type {number | { enter?: number, exit?: number }}\n */\n timeout: function timeout(props) {\n var pt = process.env.NODE_ENV !== \"production\" ? _PropTypes.timeoutsShape : {};;\n if (!props.addEndListener) pt = pt.isRequired;\n\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n return pt.apply(void 0, [props].concat(args));\n },\n\n /**\n * Add a custom transition end trigger. Called with the transitioning\n * DOM node and a `done` callback. Allows for more fine grained transition end\n * logic. **Note:** Timeouts are still used as a fallback if provided.\n *\n * ```jsx\n * addEndListener={(node, done) => {\n * // use the css transitionend event to mark the finish of a transition\n * node.addEventListener('transitionend', done, false);\n * }}\n * ```\n */\n addEndListener: PropTypes.func,\n\n /**\n * Callback fired before the \"entering\" status is applied. An extra parameter\n * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n *\n * @type Function(node: HtmlElement, isAppearing: bool) -> void\n */\n onEnter: PropTypes.func,\n\n /**\n * Callback fired after the \"entering\" status is applied. An extra parameter\n * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n *\n * @type Function(node: HtmlElement, isAppearing: bool)\n */\n onEntering: PropTypes.func,\n\n /**\n * Callback fired after the \"entered\" status is applied. An extra parameter\n * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount\n *\n * @type Function(node: HtmlElement, isAppearing: bool) -> void\n */\n onEntered: PropTypes.func,\n\n /**\n * Callback fired before the \"exiting\" status is applied.\n *\n * @type Function(node: HtmlElement) -> void\n */\n onExit: PropTypes.func,\n\n /**\n * Callback fired after the \"exiting\" status is applied.\n *\n * @type Function(node: HtmlElement) -> void\n */\n onExiting: PropTypes.func,\n\n /**\n * Callback fired after the \"exited\" status is applied.\n *\n * @type Function(node: HtmlElement) -> void\n */\n onExited: PropTypes.func // Name the function so it is clearer in the documentation\n\n} : {};\n\nfunction noop() {}\n\nTransition.defaultProps = {\n in: false,\n mountOnEnter: false,\n unmountOnExit: false,\n appear: false,\n enter: true,\n exit: true,\n onEnter: noop,\n onEntering: noop,\n onEntered: noop,\n onExit: noop,\n onExiting: noop,\n onExited: noop\n};\nTransition.UNMOUNTED = 0;\nTransition.EXITED = 1;\nTransition.ENTERING = 2;\nTransition.ENTERED = 3;\nTransition.EXITING = 4;\n\nvar _default = (0, _reactLifecyclesCompat.polyfill)(Transition);\n\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = _default;\n\nvar _react = _interopRequireDefault(require(\"react\"));\n\nvar _Transition = _interopRequireDefault(require(\"react-transition-group/Transition\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _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); }\n\nfunction _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; }\n\nvar noop = function noop() {};\n\nfunction _default(_ref) {\n var enter = _ref.enter,\n exit = _ref.exit,\n _ref$duration = _ref.duration,\n duration = _ref$duration === void 0 ? 750 : _ref$duration,\n _ref$appendPosition = _ref.appendPosition,\n appendPosition = _ref$appendPosition === void 0 ? false : _ref$appendPosition;\n return function Animation(_ref2) {\n var children = _ref2.children,\n position = _ref2.position,\n preventExitTransition = _ref2.preventExitTransition,\n props = _objectWithoutPropertiesLoose(_ref2, [\"children\", \"position\", \"preventExitTransition\"]);\n\n var enterClassName = appendPosition ? enter + \"--\" + position : enter;\n var exitClassName = appendPosition ? exit + \"--\" + position : exit;\n var enterDuration, exitDuration;\n\n if (Array.isArray(duration) && duration.length === 2) {\n enterDuration = duration[0];\n exitDuration = duration[1];\n } else {\n enterDuration = exitDuration = duration;\n }\n\n var onEnter = function onEnter(node) {\n node.classList.add(enterClassName);\n node.style.animationFillMode = 'forwards';\n node.style.animationDuration = enterDuration * 0.001 + \"s\";\n };\n\n var onEntered = function onEntered(node) {\n node.classList.remove(enterClassName);\n node.style.cssText = '';\n };\n\n var onExit = function onExit(node) {\n node.classList.add(exitClassName);\n node.style.animationFillMode = 'forwards';\n node.style.animationDuration = exitDuration * 0.001 + \"s\";\n };\n\n return _react.default.createElement(_Transition.default, _extends({}, props, {\n timeout: preventExitTransition ? 0 : {\n enter: enterDuration,\n exit: exitDuration\n },\n onEnter: onEnter,\n onEntered: onEntered,\n onExit: preventExitTransition ? noop : onExit\n }), children);\n };\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.Flip = exports.Zoom = exports.Slide = exports.Bounce = void 0;\n\nvar _cssTransition = _interopRequireDefault(require(\"./../utils/cssTransition\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar Bounce = (0, _cssTransition.default)({\n enter: 'Toastify__bounce-enter',\n exit: 'Toastify__bounce-exit',\n appendPosition: true\n});\nexports.Bounce = Bounce;\nvar Slide = (0, _cssTransition.default)({\n enter: 'Toastify__slide-enter',\n exit: 'Toastify__slide-exit',\n duration: [450, 750],\n appendPosition: true\n});\nexports.Slide = Slide;\nvar Zoom = (0, _cssTransition.default)({\n enter: 'Toastify__zoom-enter',\n exit: 'Toastify__zoom-exit'\n});\nexports.Zoom = Zoom;\nvar Flip = (0, _cssTransition.default)({\n enter: 'Toastify__flip-enter',\n exit: 'Toastify__flip-exit'\n});\nexports.Flip = Flip;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\nvar eventManager = {\n list: new Map(),\n on: function on(event, callback) {\n this.list.has(event) || this.list.set(event, []);\n this.list.get(event).push(callback);\n return this;\n },\n off: function off(event) {\n this.list.delete(event);\n return this;\n },\n emit: function emit(event) {\n for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n args[_key - 1] = arguments[_key];\n }\n\n if (!this.list.has(event)) {\n return false;\n }\n\n this.list.get(event).forEach(function (callback) {\n return setTimeout(function () {\n return callback.call.apply(callback, [null].concat(args));\n }, 0);\n });\n return true;\n }\n};\nvar _default = eventManager;\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _react = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _classnames = _interopRequireDefault(require(\"classnames\"));\n\nvar _TransitionGroup = _interopRequireDefault(require(\"react-transition-group/TransitionGroup\"));\n\nvar _Toast = _interopRequireDefault(require(\"./Toast\"));\n\nvar _CloseButton = _interopRequireDefault(require(\"./CloseButton\"));\n\nvar _Transitions = require(\"./Transitions\");\n\nvar _constant = require(\"./../utils/constant\");\n\nvar _eventManager = _interopRequireDefault(require(\"./../utils/eventManager\"));\n\nvar _propValidator = require(\"./../utils/propValidator\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }\n\nfunction _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nfunction _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); }\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar ToastContainer =\n/*#__PURE__*/\nfunction (_Component) {\n _inheritsLoose(ToastContainer, _Component);\n\n function ToastContainer() {\n var _this;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n _this = _Component.call.apply(_Component, [this].concat(args)) || this;\n _this.state = {\n toast: []\n };\n _this.toastKey = 1;\n _this.collection = {};\n\n _this.isToastActive = function (id) {\n return _this.state.toast.indexOf(id) !== -1;\n };\n\n return _this;\n }\n\n var _proto = ToastContainer.prototype;\n\n _proto.componentDidMount = function componentDidMount() {\n var _this2 = this;\n\n _eventManager.default.on(_constant.ACTION.SHOW, function (content, options) {\n return _this2.show(content, options);\n }).on(_constant.ACTION.CLEAR, function (id) {\n return !id ? _this2.clear() : _this2.removeToast(id);\n }).emit(_constant.ACTION.DID_MOUNT, this);\n };\n\n _proto.componentWillUnmount = function componentWillUnmount() {\n _eventManager.default.off(_constant.ACTION.SHOW).off(_constant.ACTION.CLEAR).emit(_constant.ACTION.WILL_UNMOUNT);\n };\n\n _proto.removeToast = function removeToast(id) {\n this.setState({\n toast: this.state.toast.filter(function (v) {\n return v !== id;\n })\n }, this.dispatchChange);\n };\n\n _proto.dispatchChange = function dispatchChange() {\n _eventManager.default.emit(_constant.ACTION.ON_CHANGE, this.state.toast.length);\n };\n\n _proto.makeCloseButton = function makeCloseButton(toastClose, toastId, type) {\n var _this3 = this;\n\n var closeButton = this.props.closeButton;\n\n if ((0, _react.isValidElement)(toastClose) || toastClose === false) {\n closeButton = toastClose;\n }\n\n return closeButton === false ? false : (0, _react.cloneElement)(closeButton, {\n closeToast: function closeToast() {\n return _this3.removeToast(toastId);\n },\n type: type\n });\n };\n\n _proto.getAutoCloseDelay = function getAutoCloseDelay(toastAutoClose) {\n return toastAutoClose === false || (0, _propValidator.isValidDelay)(toastAutoClose) ? toastAutoClose : this.props.autoClose;\n };\n\n _proto.canBeRendered = function canBeRendered(content) {\n return (0, _react.isValidElement)(content) || typeof content === 'string' || typeof content === 'number' || typeof content === 'function';\n };\n\n _proto.parseClassName = function parseClassName(prop) {\n if (typeof prop === 'string') {\n return prop;\n } else if (prop !== null && typeof prop === 'object' && 'toString' in prop) {\n return prop.toString();\n }\n\n return null;\n };\n\n _proto.show = function show(content, options) {\n var _this4 = this,\n _extends2;\n\n if (!this.canBeRendered(content)) {\n throw new Error(\"The element you provided cannot be rendered. You provided an element of type \" + typeof content);\n }\n\n var toastId = options.toastId;\n\n var closeToast = function closeToast() {\n return _this4.removeToast(toastId);\n };\n\n var toastOptions = {\n id: toastId,\n // ⚠️ if no options.key, this.toastKey - 1 is assigned\n key: options.key || this.toastKey++,\n type: options.type,\n closeToast: closeToast,\n updateId: options.updateId,\n rtl: this.props.rtl,\n position: options.position || this.props.position,\n transition: options.transition || this.props.transition,\n className: this.parseClassName(options.className || this.props.toastClassName),\n bodyClassName: this.parseClassName(options.bodyClassName || this.props.bodyClassName),\n closeButton: this.makeCloseButton(options.closeButton, toastId, options.type),\n pauseOnHover: typeof options.pauseOnHover === 'boolean' ? options.pauseOnHover : this.props.pauseOnHover,\n pauseOnFocusLoss: typeof options.pauseOnFocusLoss === 'boolean' ? options.pauseOnFocusLoss : this.props.pauseOnFocusLoss,\n draggable: typeof options.draggable === 'boolean' ? options.draggable : this.props.draggable,\n draggablePercent: typeof options.draggablePercent === 'number' && !isNaN(options.draggablePercent) ? options.draggablePercent : this.props.draggablePercent,\n closeOnClick: typeof options.closeOnClick === 'boolean' ? options.closeOnClick : this.props.closeOnClick,\n progressClassName: this.parseClassName(options.progressClassName || this.props.progressClassName),\n progressStyle: this.props.progressStyle,\n autoClose: this.getAutoCloseDelay(options.autoClose),\n hideProgressBar: typeof options.hideProgressBar === 'boolean' ? options.hideProgressBar : this.props.hideProgressBar,\n progress: parseFloat(options.progress),\n isProgressDone: options.isProgressDone\n };\n typeof options.onOpen === 'function' && (toastOptions.onOpen = options.onOpen);\n typeof options.onClose === 'function' && (toastOptions.onClose = options.onClose); // add closeToast function to react component only\n\n if ((0, _react.isValidElement)(content) && typeof content.type !== 'string' && typeof content.type !== 'number') {\n content = (0, _react.cloneElement)(content, {\n closeToast: closeToast\n });\n } else if (typeof content === 'function') {\n content = content({\n closeToast: closeToast\n });\n }\n\n this.collection = _extends({}, this.collection, (_extends2 = {}, _extends2[toastId] = {\n position: toastOptions.position,\n options: toastOptions,\n content: content\n }, _extends2));\n this.setState({\n toast: (toastOptions.updateId ? _toConsumableArray(this.state.toast) : _toConsumableArray(this.state.toast).concat([toastId])).filter(function (id) {\n return id !== options.staleToastId;\n })\n }, this.dispatchChange);\n };\n\n _proto.makeToast = function makeToast(content, options) {\n return _react.default.createElement(_Toast.default, _extends({}, options, {\n isDocumentHidden: this.state.isDocumentHidden,\n key: \"toast-\" + options.key\n }), content);\n };\n\n _proto.clear = function clear() {\n this.setState({\n toast: []\n });\n };\n\n _proto.renderToast = function renderToast() {\n var _this5 = this;\n\n var toastToRender = {};\n var _this$props = this.props,\n className = _this$props.className,\n style = _this$props.style,\n newestOnTop = _this$props.newestOnTop;\n var collection = newestOnTop ? Object.keys(this.collection).reverse() : Object.keys(this.collection); // group toast by position\n\n collection.forEach(function (toastId) {\n var _this5$collection$toa = _this5.collection[toastId],\n position = _this5$collection$toa.position,\n options = _this5$collection$toa.options,\n content = _this5$collection$toa.content;\n toastToRender[position] || (toastToRender[position] = []);\n\n if (_this5.state.toast.indexOf(options.id) !== -1) {\n toastToRender[position].push(_this5.makeToast(content, options));\n } else {\n toastToRender[position].push(null);\n delete _this5.collection[toastId];\n }\n });\n return Object.keys(toastToRender).map(function (position) {\n var disablePointer = toastToRender[position].length === 1 && toastToRender[position][0] === null;\n var props = {\n className: (0, _classnames.default)('Toastify__toast-container', \"Toastify__toast-container--\" + position, {\n 'Toastify__toast-container--rtl': _this5.props.rtl\n }, _this5.parseClassName(className)),\n style: disablePointer ? _extends({}, style, {\n pointerEvents: 'none'\n }) : _extends({}, style)\n };\n return _react.default.createElement(_TransitionGroup.default, _extends({}, props, {\n key: \"container-\" + position\n }), toastToRender[position]);\n });\n };\n\n _proto.render = function render() {\n return _react.default.createElement(\"div\", {\n className: \"Toastify\"\n }, this.renderToast());\n };\n\n return ToastContainer;\n}(_react.Component);\n\nToastContainer.propTypes = {\n /**\n * Set toast position\n */\n position: _propTypes.default.oneOf((0, _propValidator.objectValues)(_constant.POSITION)),\n\n /**\n * Disable or set autoClose delay\n */\n autoClose: _propValidator.falseOrDelay,\n\n /**\n * Disable or set a custom react element for the close button\n */\n closeButton: _propValidator.falseOrElement,\n\n /**\n * Hide or not progress bar when autoClose is enabled\n */\n hideProgressBar: _propTypes.default.bool,\n\n /**\n * Pause toast duration on hover\n */\n pauseOnHover: _propTypes.default.bool,\n\n /**\n * Dismiss toast on click\n */\n closeOnClick: _propTypes.default.bool,\n\n /**\n * Newest on top\n */\n newestOnTop: _propTypes.default.bool,\n\n /**\n * An optional className\n */\n className: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n\n /**\n * An optional style\n */\n style: _propTypes.default.object,\n\n /**\n * An optional className for the toast\n */\n toastClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n\n /**\n * An optional className for the toast body\n */\n bodyClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n\n /**\n * An optional className for the toast progress bar\n */\n progressClassName: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]),\n\n /**\n * An optional style for the toast progress bar\n */\n progressStyle: _propTypes.default.object,\n\n /**\n * Define enter and exit transition using react-transition-group\n */\n transition: _propTypes.default.func,\n\n /**\n * Support rtl display\n */\n rtl: _propTypes.default.bool,\n\n /**\n * Allow toast to be draggable\n */\n draggable: _propTypes.default.bool,\n\n /**\n * The percentage of the toast's width it takes for a drag to dismiss a toast\n */\n draggablePercent: _propTypes.default.number,\n\n /**\n * Pause the toast on focus loss\n */\n pauseOnFocusLoss: _propTypes.default.bool\n};\nToastContainer.defaultProps = {\n position: _constant.POSITION.TOP_RIGHT,\n transition: _Transitions.Bounce,\n rtl: false,\n autoClose: 5000,\n hideProgressBar: false,\n closeButton: _react.default.createElement(_CloseButton.default, null),\n pauseOnHover: true,\n pauseOnFocusLoss: true,\n closeOnClick: true,\n newestOnTop: false,\n draggable: true,\n draggablePercent: 80,\n className: null,\n style: null,\n toastClassName: null,\n bodyClassName: null,\n progressClassName: null,\n progressStyle: null\n};\nvar _default = ToastContainer;\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _eventManager = _interopRequireDefault(require(\"./utils/eventManager\"));\n\nvar _constant = require(\"./utils/constant\");\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _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); }\n\nvar container = null;\nvar queue = [];\n\nvar noop = function noop() {\n return false;\n};\n/**\n * Merge provided options with the defaults settings and generate the toastId\n */\n\n\nfunction mergeOptions(options, type) {\n return _extends({}, options, {\n type: type,\n toastId: getToastId(options)\n });\n}\n/**\n * Generate a random toastId\n */\n\n\nfunction generateToastId() {\n return (Math.random().toString(36) + Date.now().toString(36)).substr(2, 10);\n}\n/**\n * Generate the toastId either automatically or by provided toastId\n */\n\n\nfunction getToastId(options) {\n if (options && (typeof options.toastId === 'string' || typeof options.toastId === 'number' && !isNaN(options.toastId))) {\n return options.toastId;\n }\n\n return generateToastId();\n}\n/**\n * Dispatch toast. If the container is not mounted, the toast is enqueued\n */\n\n\nfunction emitEvent(content, options) {\n if (container !== null) {\n _eventManager.default.emit(_constant.ACTION.SHOW, content, options);\n } else {\n queue.push({\n action: _constant.ACTION.SHOW,\n content: content,\n options: options\n });\n }\n\n return options.toastId;\n}\n\nvar toast = _extends(function (content, options) {\n return emitEvent(content, mergeOptions(options, options && options.type || _constant.TYPE.DEFAULT));\n}, {\n success: function success(content, options) {\n return emitEvent(content, mergeOptions(options, _constant.TYPE.SUCCESS));\n },\n info: function info(content, options) {\n return emitEvent(content, mergeOptions(options, _constant.TYPE.INFO));\n },\n warn: function warn(content, options) {\n return emitEvent(content, mergeOptions(options, _constant.TYPE.WARNING));\n },\n warning: function warning(content, options) {\n return emitEvent(content, mergeOptions(options, _constant.TYPE.WARNING));\n },\n error: function error(content, options) {\n return emitEvent(content, mergeOptions(options, _constant.TYPE.ERROR));\n },\n dismiss: function dismiss(id) {\n if (id === void 0) {\n id = null;\n }\n\n return container && _eventManager.default.emit(_constant.ACTION.CLEAR, id);\n },\n isActive: noop,\n update: function update(toastId, options) {\n setTimeout(function () {\n if (container && typeof container.collection[toastId] !== 'undefined') {\n var _container$collection = container.collection[toastId],\n oldOptions = _container$collection.options,\n oldContent = _container$collection.content;\n\n var nextOptions = _extends({}, oldOptions, options, {\n toastId: options.toastId || toastId\n });\n\n if (!options.toastId || options.toastId === toastId) {\n nextOptions.updateId = generateToastId();\n } else {\n nextOptions.staleToastId = toastId;\n }\n\n var content = typeof nextOptions.render !== 'undefined' ? nextOptions.render : oldContent;\n delete nextOptions.render;\n emitEvent(content, nextOptions);\n }\n }, 0);\n },\n done: function done(id, progress) {\n if (progress === void 0) {\n progress = 1;\n }\n\n toast.update(id, {\n progress: progress,\n isProgressDone: true\n });\n },\n onChange: function onChange(callback) {\n if (typeof callback === 'function') {\n _eventManager.default.on(_constant.ACTION.ON_CHANGE, callback);\n }\n },\n POSITION: _constant.POSITION,\n TYPE: _constant.TYPE\n});\n/**\n * Wait until the ToastContainer is mounted to dispatch the toast\n * and attach isActive method\n */\n\n\n_eventManager.default.on(_constant.ACTION.DID_MOUNT, function (containerInstance) {\n container = containerInstance;\n\n toast.isActive = function (id) {\n return container.isToastActive(id);\n };\n\n queue.forEach(function (item) {\n _eventManager.default.emit(item.action, item.content, item.options);\n });\n queue = [];\n}).on(_constant.ACTION.WILL_UNMOUNT, function () {\n container = null;\n toast.isActive = noop;\n});\n\nvar _default = toast;\nexports.default = _default;","\"use strict\";\n\nexports.__esModule = true;\n\nvar _ToastContainer = _interopRequireDefault(require(\"./components/ToastContainer\"));\n\nexports.ToastContainer = _ToastContainer.default;\n\nvar _Transitions = require(\"./components/Transitions\");\n\nexports.Bounce = _Transitions.Bounce;\nexports.Slide = _Transitions.Slide;\nexports.Zoom = _Transitions.Zoom;\nexports.Flip = _Transitions.Flip;\n\nvar _constant = require(\"./utils/constant\");\n\nexports.ToastPosition = _constant.POSITION;\nexports.ToastType = _constant.TYPE;\n\nvar _toast = _interopRequireDefault(require(\"./toast\"));\n\nexports.toast = _toast.default;\n\nvar _cssTransition = _interopRequireDefault(require(\"./utils/cssTransition\"));\n\nexports.cssTransition = _cssTransition.default;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }","import React, {Component} from 'react';\nimport FormContext from './FormContext';\nimport {toast} from 'react-toastify';\n\nexport default class Form extends Component\n{\n constructor(props) {\n super(props)\n this.state = {\n data: props.data\n }\n\n this.displayError = true\n this.handleError(props)\n }\n\n componentWillReceiveProps(props)\n {\n this.handleError(props)\n this.setState({\n data: props.data\n })\n }\n\n handleError(props)\n {\n if (props.data && props.data.error && props.toast && this.displayError == true) {\n toast.error(props.data.error)\n this.displayError = false\n }\n }\n\n render()\n {\n return (\n \n
\n {this.renderError()}\n {this.props.children}\n
\n \n )\n }\n\n _onSubmit = (e) => {\n e.preventDefault()\n this.props.onSubmit()\n this.displayError = true\n return false;\n }\n\n renderError()\n {\n if (this.state.data && this.state.data.error && !this.props.toast)\n {\n return (\n

{this.state.data.error}

\n )\n }\n\n return null\n }\n}\n\nForm.defaultProps = {\n data: null,\n toast: false,\n onSubmit: () => {\n console.log('[Form] submitted')\n }\n}","import React, {Component} from 'react';\nimport {FormConsumer} from \"./FormContext\";\nimport FormItemError from \"./FormItemError\";\n\nexport default class Input extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderInput(data)}\n \n )\n }\n\n renderInput(data)\n {\n let props = {...this.props}\n if (props.children) delete props.children\n if (props.onChangeValue) delete props.onChangeValue\n return (\n
\n {this.renderLabel(data)}\n this.props.onChangeValue(e.target.value)} {...props} />\n \n
\n )\n }\n\n renderLabel(data)\n {\n if (this.props.label) {\n return (\n \n )\n }\n }\n}\n\nInput.defaultProps = {\n name: 'input',\n id: 'input',\n className: 'form-control',\n type: 'text',\n onChangeValue: (text) => {}\n}","import React, {Component} from 'react';\nimport {FormConsumer} from './FormContext';\nimport FormItemError from \"./FormItemError\";\n\nconst OptionGroupContext = React.createContext({});\n\nexport class OptionGroupConsumer extends Component\n{\n render()\n {\n return (\n \n {(props) => this.props.children(props)}\n \n )\n }\n}\n\nexport default class OptionGroup extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderOptionGroup(data)}\n \n )\n }\n\n renderOptionGroup(data)\n {\n const props = {...this.props}\n return (\n
\n {this.renderLabel()}\n \n \n
\n )\n }\n\n _onChange = (e) => {\n if (this.props.multiple) {\n let value = []\n const options = e.target.options;\n for (let i = 0, l = options.length; i < l; i++) {\n if (options[i].selected) {\n value.push(options[i].value);\n }\n }\n this.props.onChangeValue(value)\n }\n else {\n this.props.onChangeValue(e.target.value)\n }\n }\n\n renderLabel()\n {\n if (!this.props.label) return null\n\n return (\n \n )\n }\n\n renderChildren()\n {\n return (\n \n {this.props.children}\n \n )\n }\n}\n\nOptionGroup.defaultProps = {\n name: 'select',\n className: 'form-control',\n onChangeValue: (value) => {}\n}","import React, {Component} from 'react';\nimport {OptionGroupConsumer} from \"./OptionGroup\";\n\nexport default class Option extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderOption(data)}\n \n )\n }\n\n renderOption(data)\n {\n let props = {...this.props}\n\n return (\n \n )\n }\n}\n\nOption.defaultProps = {\n value: 'option'\n}","import React, {Component} from 'react';\nimport {FormConsumer} from './FormContext';\nimport FormItemError from \"./FormItemError\";\n\nconst RadioGroupContext = React.createContext({});\n\nexport class RadioGroupConsumer extends Component\n{\n render()\n {\n return (\n \n {(props) => this.props.children(props)}\n \n )\n }\n}\n\nexport default class RadioGroup extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderRadioGroup(data)}\n \n )\n }\n\n renderRadioGroup(data)\n {\n return (\n
\n {this.renderLabel()}\n {this.renderChildren()}\n \n
\n )\n }\n\n renderLabel()\n {\n if (!this.props.label) return null\n\n return (\n

{this.props.label}

\n )\n }\n\n renderChildren()\n {\n return (\n this.props.onChangeValue(value),\n value: this.props.value\n }}>\n {this.props.children}\n \n )\n }\n}\n\nRadioGroup.defaultProps = {\n name: 'radio',\n onChangeValue: (value) => {}\n}","import React, {Component} from 'react';\nimport {RadioGroupConsumer} from \"./RadioGroup\";\n\nexport default class Radio extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderRadio(data)}\n \n )\n }\n\n renderRadio(data)\n {\n let props = {...this.props}\n if (props.children) delete props.children\n\n return (\n
\n {\n if (e.target.checked)\n data.onChangeValue(this.props.value)\n }}\n {...props} />\n {this.renderLabel(data)}\n
\n )\n }\n\n renderLabel(data)\n {\n if (this.props.children.length) {\n return (\n \n )\n }\n }\n}\n\nRadio.defaultProps = {\n value: 'option',\n className: 'form-check-input'\n}","import React, {Component} from 'react';\n\nexport default class Submit extends Component {\n render() {\n return (\n \n )\n }\n}\n\nSubmit.defaultProps = {\n className: 'btn btn-primary'\n}","import React, {Component} from 'react';\nimport {FormConsumer} from \"./FormContext\";\nimport FormItemError from \"./FormItemError\";\n\nexport default class TextArea extends Component\n{\n render()\n {\n return (\n \n {(data) => this.renderTextArea(data)}\n \n )\n }\n\n renderTextArea(data)\n {\n let props = {...this.props}\n if (props.onChangeValue) delete props.onChangeValue\n return (\n
\n {this.renderLabel(data)}\n