antd3-esm 1.0.1

package/dist/antd/es/statistic.js

@@ -0,0 +1,650 @@
+import { n, g as getDefaultExportFromCjs, s as withConfigConsumer, c as classNames, o as interopDefault, q as moment } from '../../config-provider.js';
+import * as React from 'react';
+import { r as require_baseToString, a as requireToString } from '../../toString.js';
+import { r as require_hasUnicode, a as require_stringToArray } from '../../_stringToArray.js';
+import { r as require_baseProperty, a as requireToInteger } from '../../toInteger.js';
+import { p as polyfill } from '../../menu.js';
+import '../../tree.js';
+import '../../input.js';
+import '../../icon.js';
+import '../../_arrayMap.js';
+import 'react-dom';
+
+var css = "/* stylelint-disable at-rule-empty-line-before,at-rule-name-space-after,at-rule-no-unknown */\n/* stylelint-disable no-duplicate-selectors */\n/* stylelint-disable */\n/* stylelint-disable declaration-bang-space-before,no-duplicate-selectors,string-no-newline */\n.ant-statistic {\n  box-sizing: border-box;\n  margin: 0;\n  padding: 0;\n  color: rgba(0, 0, 0, 0.65);\n  font-size: 14px;\n  font-variant: tabular-nums;\n  line-height: 1.5;\n  list-style: none;\n  font-feature-settings: 'tnum';\n}\n.ant-statistic-title {\n  margin-bottom: 4px;\n  color: rgba(0, 0, 0, 0.45);\n  font-size: 14px;\n}\n.ant-statistic-content {\n  color: rgba(0, 0, 0, 0.85);\n  font-size: 24px;\n  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'PingFang SC', 'Hiragino Sans GB', 'Microsoft YaHei', 'Helvetica Neue', Helvetica, Arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';\n}\n.ant-statistic-content-value-decimal {\n  font-size: 16px;\n}\n.ant-statistic-content-prefix,\n.ant-statistic-content-suffix {\n  display: inline-block;\n}\n.ant-statistic-content-prefix {\n  margin-right: 4px;\n}\n.ant-statistic-content-suffix {\n  margin-left: 4px;\n  font-size: 16px;\n}\n/*# sourceMappingURL=index.css.map */";
+n(css,{"prepend":true});
+
+/** Used as references for various `Number` constants. */
+
+var _baseRepeat;
+var hasRequired_baseRepeat;
+
+function require_baseRepeat () {
+	if (hasRequired_baseRepeat) return _baseRepeat;
+	hasRequired_baseRepeat = 1;
+	var MAX_SAFE_INTEGER = 9007199254740991;
+
+	/* Built-in method references for those with the same name as other `lodash` methods. */
+	var nativeFloor = Math.floor;
+
+	/**
+	 * The base implementation of `_.repeat` which doesn't coerce arguments.
+	 *
+	 * @private
+	 * @param {string} string The string to repeat.
+	 * @param {number} n The number of times to repeat the string.
+	 * @returns {string} Returns the repeated string.
+	 */
+	function baseRepeat(string, n) {
+	  var result = '';
+	  if (!string || n < 1 || n > MAX_SAFE_INTEGER) {
+	    return result;
+	  }
+	  // Leverage the exponentiation by squaring algorithm for a faster repeat.
+	  // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.
+	  do {
+	    if (n % 2) {
+	      result += string;
+	    }
+	    n = nativeFloor(n / 2);
+	    if (n) {
+	      string += string;
+	    }
+	  } while (n);
+
+	  return result;
+	}
+
+	_baseRepeat = baseRepeat;
+	return _baseRepeat;
+}
+
+/**
+ * The base implementation of `_.slice` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to slice.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns the slice of `array`.
+ */
+
+var _baseSlice;
+var hasRequired_baseSlice;
+
+function require_baseSlice () {
+	if (hasRequired_baseSlice) return _baseSlice;
+	hasRequired_baseSlice = 1;
+	function baseSlice(array, start, end) {
+	  var index = -1,
+	      length = array.length;
+
+	  if (start < 0) {
+	    start = -start > length ? 0 : (length + start);
+	  }
+	  end = end > length ? length : end;
+	  if (end < 0) {
+	    end += length;
+	  }
+	  length = start > end ? 0 : ((end - start) >>> 0);
+	  start >>>= 0;
+
+	  var result = Array(length);
+	  while (++index < length) {
+	    result[index] = array[index + start];
+	  }
+	  return result;
+	}
+
+	_baseSlice = baseSlice;
+	return _baseSlice;
+}
+
+var _castSlice;
+var hasRequired_castSlice;
+
+function require_castSlice () {
+	if (hasRequired_castSlice) return _castSlice;
+	hasRequired_castSlice = 1;
+	var baseSlice = require_baseSlice();
+
+	/**
+	 * Casts `array` to a slice if it's needed.
+	 *
+	 * @private
+	 * @param {Array} array The array to inspect.
+	 * @param {number} start The start position.
+	 * @param {number} [end=array.length] The end position.
+	 * @returns {Array} Returns the cast slice.
+	 */
+	function castSlice(array, start, end) {
+	  var length = array.length;
+	  end = end === undefined ? length : end;
+	  return (!start && end >= length) ? array : baseSlice(array, start, end);
+	}
+
+	_castSlice = castSlice;
+	return _castSlice;
+}
+
+var _asciiSize;
+var hasRequired_asciiSize;
+
+function require_asciiSize () {
+	if (hasRequired_asciiSize) return _asciiSize;
+	hasRequired_asciiSize = 1;
+	var baseProperty = require_baseProperty();
+
+	/**
+	 * Gets the size of an ASCII `string`.
+	 *
+	 * @private
+	 * @param {string} string The string inspect.
+	 * @returns {number} Returns the string size.
+	 */
+	var asciiSize = baseProperty('length');
+
+	_asciiSize = asciiSize;
+	return _asciiSize;
+}
+
+/** Used to compose unicode character classes. */
+
+var _unicodeSize;
+var hasRequired_unicodeSize;
+
+function require_unicodeSize () {
+	if (hasRequired_unicodeSize) return _unicodeSize;
+	hasRequired_unicodeSize = 1;
+	var rsAstralRange = '\\ud800-\\udfff',
+	    rsComboMarksRange = '\\u0300-\\u036f',
+	    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+	    rsComboSymbolsRange = '\\u20d0-\\u20ff',
+	    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
+	    rsVarRange = '\\ufe0e\\ufe0f';
+
+	/** Used to compose unicode capture groups. */
+	var rsAstral = '[' + rsAstralRange + ']',
+	    rsCombo = '[' + rsComboRange + ']',
+	    rsFitz = '\\ud83c[\\udffb-\\udfff]',
+	    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
+	    rsNonAstral = '[^' + rsAstralRange + ']',
+	    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
+	    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
+	    rsZWJ = '\\u200d';
+
+	/** Used to compose unicode regexes. */
+	var reOptMod = rsModifier + '?',
+	    rsOptVar = '[' + rsVarRange + ']?',
+	    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
+	    rsSeq = rsOptVar + reOptMod + rsOptJoin,
+	    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
+
+	/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+	var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
+
+	/**
+	 * Gets the size of a Unicode `string`.
+	 *
+	 * @private
+	 * @param {string} string The string inspect.
+	 * @returns {number} Returns the string size.
+	 */
+	function unicodeSize(string) {
+	  var result = reUnicode.lastIndex = 0;
+	  while (reUnicode.test(string)) {
+	    ++result;
+	  }
+	  return result;
+	}
+
+	_unicodeSize = unicodeSize;
+	return _unicodeSize;
+}
+
+var _stringSize;
+var hasRequired_stringSize;
+
+function require_stringSize () {
+	if (hasRequired_stringSize) return _stringSize;
+	hasRequired_stringSize = 1;
+	var asciiSize = require_asciiSize(),
+	    hasUnicode = require_hasUnicode(),
+	    unicodeSize = require_unicodeSize();
+
+	/**
+	 * Gets the number of symbols in `string`.
+	 *
+	 * @private
+	 * @param {string} string The string to inspect.
+	 * @returns {number} Returns the string size.
+	 */
+	function stringSize(string) {
+	  return hasUnicode(string)
+	    ? unicodeSize(string)
+	    : asciiSize(string);
+	}
+
+	_stringSize = stringSize;
+	return _stringSize;
+}
+
+var _createPadding;
+var hasRequired_createPadding;
+
+function require_createPadding () {
+	if (hasRequired_createPadding) return _createPadding;
+	hasRequired_createPadding = 1;
+	var baseRepeat = require_baseRepeat(),
+	    baseToString = require_baseToString(),
+	    castSlice = require_castSlice(),
+	    hasUnicode = require_hasUnicode(),
+	    stringSize = require_stringSize(),
+	    stringToArray = require_stringToArray();
+
+	/* Built-in method references for those with the same name as other `lodash` methods. */
+	var nativeCeil = Math.ceil;
+
+	/**
+	 * Creates the padding for `string` based on `length`. The `chars` string
+	 * is truncated if the number of characters exceeds `length`.
+	 *
+	 * @private
+	 * @param {number} length The padding length.
+	 * @param {string} [chars=' '] The string used as padding.
+	 * @returns {string} Returns the padding for `string`.
+	 */
+	function createPadding(length, chars) {
+	  chars = chars === undefined ? ' ' : baseToString(chars);
+
+	  var charsLength = chars.length;
+	  if (charsLength < 2) {
+	    return charsLength ? baseRepeat(chars, length) : chars;
+	  }
+	  var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));
+	  return hasUnicode(chars)
+	    ? castSlice(stringToArray(result), 0, length).join('')
+	    : result.slice(0, length);
+	}
+
+	_createPadding = createPadding;
+	return _createPadding;
+}
+
+var padEnd_1;
+var hasRequiredPadEnd;
+
+function requirePadEnd () {
+	if (hasRequiredPadEnd) return padEnd_1;
+	hasRequiredPadEnd = 1;
+	var createPadding = require_createPadding(),
+	    stringSize = require_stringSize(),
+	    toInteger = requireToInteger(),
+	    toString = requireToString();
+
+	/**
+	 * Pads `string` on the right side if it's shorter than `length`. Padding
+	 * characters are truncated if they exceed `length`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category String
+	 * @param {string} [string=''] The string to pad.
+	 * @param {number} [length=0] The padding length.
+	 * @param {string} [chars=' '] The string used as padding.
+	 * @returns {string} Returns the padded string.
+	 * @example
+	 *
+	 * _.padEnd('abc', 6);
+	 * // => 'abc   '
+	 *
+	 * _.padEnd('abc', 6, '_-');
+	 * // => 'abc_-_'
+	 *
+	 * _.padEnd('abc', 3);
+	 * // => 'abc'
+	 */
+	function padEnd(string, length, chars) {
+	  string = toString(string);
+	  length = toInteger(length);
+
+	  var strLength = length ? stringSize(string) : 0;
+	  return (length && strLength < length)
+	    ? (string + createPadding(length - strLength, chars))
+	    : string;
+	}
+
+	padEnd_1 = padEnd;
+	return padEnd_1;
+}
+
+var padEndExports = requirePadEnd();
+var padEnd = /*@__PURE__*/getDefaultExportFromCjs(padEndExports);
+
+var StatisticNumber = function StatisticNumber(props) {
+  var value = props.value,
+      formatter = props.formatter,
+      precision = props.precision,
+      decimalSeparator = props.decimalSeparator,
+      _props$groupSeparator = props.groupSeparator,
+      groupSeparator = _props$groupSeparator === void 0 ? '' : _props$groupSeparator,
+      prefixCls = props.prefixCls;
+  var valueNode;
+
+  if (typeof formatter === 'function') {
+    // Customize formatter
+    valueNode = formatter(value);
+  } else {
+    // Internal formatter
+    var val = String(value);
+    var cells = val.match(/^(-?)(\d*)(\.(\d+))?$/); // Process if illegal number
+
+    if (!cells) {
+      valueNode = val;
+    } else {
+      var negative = cells[1];
+
+      var _int = cells[2] || '0';
+
+      var decimal = cells[4] || '';
+      _int = _int.replace(/\B(?=(\d{3})+(?!\d))/g, groupSeparator);
+
+      if (typeof precision === 'number') {
+        decimal = padEnd(decimal, precision, '0').slice(0, precision);
+      }
+
+      if (decimal) {
+        decimal = "".concat(decimalSeparator).concat(decimal);
+      }
+
+      valueNode = [/*#__PURE__*/React.createElement("span", {
+        key: "int",
+        className: "".concat(prefixCls, "-content-value-int")
+      }, negative, _int), decimal && /*#__PURE__*/React.createElement("span", {
+        key: "decimal",
+        className: "".concat(prefixCls, "-content-value-decimal")
+      }, decimal)];
+    }
+  }
+
+  return /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-content-value")
+  }, valueNode);
+};
+
+function _extends$1() { _extends$1 = 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$1.apply(this, arguments); }
+
+var Statistic = function Statistic(props) {
+  var prefixCls = props.prefixCls,
+      className = props.className,
+      style = props.style,
+      valueStyle = props.valueStyle,
+      _props$value = props.value,
+      value = _props$value === void 0 ? 0 : _props$value,
+      title = props.title,
+      valueRender = props.valueRender,
+      prefix = props.prefix,
+      suffix = props.suffix;
+  var valueNode = /*#__PURE__*/React.createElement(StatisticNumber, _extends$1({}, props, {
+    value: value
+  }));
+
+  if (valueRender) {
+    valueNode = valueRender(valueNode);
+  }
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: classNames(prefixCls, className),
+    style: style
+  }, title && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-title")
+  }, title), /*#__PURE__*/React.createElement("div", {
+    style: valueStyle,
+    className: "".concat(prefixCls, "-content")
+  }, prefix && /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-content-prefix")
+  }, prefix), valueNode, suffix && /*#__PURE__*/React.createElement("span", {
+    className: "".concat(prefixCls, "-content-suffix")
+  }, suffix)));
+};
+
+Statistic.defaultProps = {
+  decimalSeparator: '.',
+  groupSeparator: ','
+};
+var WrapperStatistic = withConfigConsumer({
+  prefixCls: 'statistic'
+})(Statistic);
+
+var padStart_1;
+var hasRequiredPadStart;
+
+function requirePadStart () {
+	if (hasRequiredPadStart) return padStart_1;
+	hasRequiredPadStart = 1;
+	var createPadding = require_createPadding(),
+	    stringSize = require_stringSize(),
+	    toInteger = requireToInteger(),
+	    toString = requireToString();
+
+	/**
+	 * Pads `string` on the left side if it's shorter than `length`. Padding
+	 * characters are truncated if they exceed `length`.
+	 *
+	 * @static
+	 * @memberOf _
+	 * @since 4.0.0
+	 * @category String
+	 * @param {string} [string=''] The string to pad.
+	 * @param {number} [length=0] The padding length.
+	 * @param {string} [chars=' '] The string used as padding.
+	 * @returns {string} Returns the padded string.
+	 * @example
+	 *
+	 * _.padStart('abc', 6);
+	 * // => '   abc'
+	 *
+	 * _.padStart('abc', 6, '_-');
+	 * // => '_-_abc'
+	 *
+	 * _.padStart('abc', 3);
+	 * // => 'abc'
+	 */
+	function padStart(string, length, chars) {
+	  string = toString(string);
+	  length = toInteger(length);
+
+	  var strLength = length ? stringSize(string) : 0;
+	  return (length && strLength < length)
+	    ? (createPadding(length - strLength, chars) + string)
+	    : string;
+	}
+
+	padStart_1 = padStart;
+	return padStart_1;
+}
+
+var padStartExports = requirePadStart();
+var padStart = /*@__PURE__*/getDefaultExportFromCjs(padStartExports);
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var timeUnits = [['Y', 1000 * 60 * 60 * 24 * 365], ['M', 1000 * 60 * 60 * 24 * 30], ['D', 1000 * 60 * 60 * 24], ['H', 1000 * 60 * 60], ['m', 1000 * 60], ['s', 1000], ['S', 1]];
+function formatTimeStr(duration, format) {
+  var leftDuration = duration;
+  var escapeRegex = /\[[^\]]*\]/g;
+  var keepList = (format.match(escapeRegex) || []).map(function (str) {
+    return str.slice(1, -1);
+  });
+  var templateText = format.replace(escapeRegex, '[]');
+  var replacedText = timeUnits.reduce(function (current, _ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+        name = _ref2[0],
+        unit = _ref2[1];
+
+    if (current.indexOf(name) !== -1) {
+      var value = Math.floor(leftDuration / unit);
+      leftDuration -= value * unit;
+      return current.replace(new RegExp("".concat(name, "+"), 'g'), function (match) {
+        var len = match.length;
+        return padStart(value.toString(), len, '0');
+      });
+    }
+
+    return current;
+  }, templateText);
+  var index = 0;
+  return replacedText.replace(escapeRegex, function () {
+    var match = keepList[index];
+    index += 1;
+    return match;
+  });
+}
+function formatCountdown(value, config) {
+  var _config$format = config.format,
+      format = _config$format === void 0 ? '' : _config$format;
+  var target = interopDefault(moment)(value).valueOf();
+  var current = interopDefault(moment)().valueOf();
+  var diff = Math.max(target - current, 0);
+  return formatTimeStr(diff, format);
+}
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var REFRESH_INTERVAL = 1000 / 30;
+
+function getTime(value) {
+  return interopDefault(moment)(value).valueOf();
+}
+
+var Countdown = /*#__PURE__*/function (_React$Component) {
+  _inherits(Countdown, _React$Component);
+
+  var _super = _createSuper(Countdown);
+
+  function Countdown() {
+    var _this;
+
+    _classCallCheck(this, Countdown);
+
+    _this = _super.apply(this, arguments);
+
+    _this.syncTimer = function () {
+      var value = _this.props.value;
+      var timestamp = getTime(value);
+
+      if (timestamp >= Date.now()) {
+        _this.startTimer();
+      } else {
+        _this.stopTimer();
+      }
+    };
+
+    _this.startTimer = function () {
+      if (_this.countdownId) return;
+      _this.countdownId = window.setInterval(function () {
+        _this.forceUpdate();
+      }, REFRESH_INTERVAL);
+    };
+
+    _this.stopTimer = function () {
+      var _this$props = _this.props,
+          onFinish = _this$props.onFinish,
+          value = _this$props.value;
+
+      if (_this.countdownId) {
+        clearInterval(_this.countdownId);
+        _this.countdownId = undefined;
+        var timestamp = getTime(value);
+
+        if (onFinish && timestamp < Date.now()) {
+          onFinish();
+        }
+      }
+    };
+
+    _this.formatCountdown = function (value, config) {
+      var format = _this.props.format;
+      return formatCountdown(value, _extends(_extends({}, config), {
+        format: format
+      }));
+    }; // Countdown do not need display the timestamp
+
+
+    _this.valueRender = function (node) {
+      return /*#__PURE__*/React.cloneElement(node, {
+        title: undefined
+      });
+    };
+
+    return _this;
+  }
+
+  _createClass(Countdown, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.syncTimer();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      this.syncTimer();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.stopTimer();
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(WrapperStatistic, _extends({
+        valueRender: this.valueRender
+      }, this.props, {
+        formatter: this.formatCountdown
+      }));
+    }
+  }]);
+
+  return Countdown;
+}(React.Component);
+
+Countdown.defaultProps = {
+  format: 'HH:mm:ss'
+};
+polyfill(Countdown);
+
+WrapperStatistic.Countdown = Countdown;
+
+export { WrapperStatistic as default };