@douyinfe/semi-ui 2.1.1 → 2.1.2

package/lib/cjs/timePicker/Combobox.js

@@ -0,0 +1,345 @@
+"use strict";
+
+var _WeakMap = require("@babel/runtime-corejs3/core-js-stable/weak-map");
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-descriptor");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
+
+var _filter = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/filter"));
+
+var _map = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/map"));
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _dateFns = require("date-fns");
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/timePicker/constants");
+
+var _index = _interopRequireDefault(require("../scrollList/index"));
+
+var _scrollItem = _interopRequireDefault(require("../scrollList/scrollItem"));
+
+var _ComboxFoundation = _interopRequireWildcard(require("@douyinfe/semi-foundation/lib/cjs/timePicker/ComboxFoundation"));
+
+var _localeConsumer = _interopRequireDefault(require("../locale/localeConsumer"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof _WeakMap !== "function") return null; var cacheBabelInterop = new _WeakMap(); var cacheNodeInterop = new _WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? _Object$getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { _Object$defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/* eslint-disable max-len */
+
+/* eslint-disable react/no-did-update-set-state */
+class Combobox extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+
+    this.cacheRefCurrent = (key, current) => {
+      if (key && typeof key === 'string') {
+        this.adapter.setCache(key, current);
+      }
+    };
+
+    this.reselect = () => {
+      const currentKeys = ['ampm', 'hour', 'minute', 'second'];
+      (0, _forEach.default)(currentKeys).call(currentKeys, key => {
+        const current = this.adapter.getCache(key);
+
+        if (current && current.scrollToIndex) {
+          current.scrollToIndex();
+        }
+      });
+    };
+
+    this.onItemChange = _ref => {
+      let {
+        type,
+        value,
+        disabled
+      } = _ref;
+      // eslint-disable-next-line prefer-const
+      let {
+        onChange,
+        use12Hours,
+        isAM,
+        format,
+        timeStampValue
+      } = this.props;
+      const transformValue = this.foundation.getDisplayDateFromTimeStamp(timeStampValue); // TODO: foundation
+
+      if (type === 'hour') {
+        if (use12Hours) {
+          if (isAM) {
+            transformValue.setHours(Number(value) % 12);
+          } else {
+            transformValue.setHours(Number(value) % 12 + 12);
+          }
+        } else {
+          transformValue.setHours(Number(value));
+        }
+      } else if (type === 'minute') {
+        transformValue.setMinutes(Number(value));
+      } else if (type === 'ampm') {
+        const ampm = value.toUpperCase();
+
+        if (use12Hours) {
+          if (ampm === 'PM') {
+            isAM = false;
+            transformValue.getHours() < 12 && transformValue.setHours(transformValue.getHours() % 12 + 12);
+          }
+
+          if (ampm === 'AM') {
+            isAM = true;
+            transformValue.getHours() >= 12 && transformValue.setHours(transformValue.getHours() - 12);
+          }
+        }
+      } else {
+        transformValue.setSeconds(Number(value));
+      }
+
+      onChange && onChange({
+        isAM,
+        value: (0, _dateFns.format)(transformValue, format && format.replace(/(\s+)A/g, '$1a')),
+        timeStampValue: Number(transformValue)
+      });
+    };
+
+    this.onEnterSelectPanel = range => {
+      const {
+        onCurrentSelectPanelChange
+      } = this.props;
+      onCurrentSelectPanelChange(range);
+    };
+
+    this.getDisplayDateFromTimeStamp = timeStampValue => this.foundation.getDisplayDateFromTimeStamp(timeStampValue);
+
+    this.foundation = new _ComboxFoundation.default(this.adapter);
+    this.state = (0, _assign.default)({}, this.foundation.initData());
+  }
+
+  componentDidUpdate(prevProps, prevState) {
+    if (prevProps.timeStampValue !== this.props.timeStampValue || prevProps.format !== this.props.format) {
+      this.setState((0, _assign.default)({}, this.foundation.initData()));
+    }
+  }
+
+  componentWillUnmount() {// this.foundation.destroy();
+  }
+
+  componentDidMount() {// this.foundation.init();
+  }
+
+  renderHourSelect(hour, locale) {
+    const {
+      prefixCls,
+      disabledHours,
+      use12Hours,
+      scrollItemProps
+    } = this.props;
+    const {
+      showHour,
+      hourOptions
+    } = this.state;
+
+    if (!showHour) {
+      return null;
+    }
+
+    const disabledOptions = disabledHours();
+    let hourOptionsAdj, hourAdj;
+
+    if (use12Hours) {
+      var _context;
+
+      hourOptionsAdj = (0, _concat.default)(_context = [12]).call(_context, (0, _filter.default)(hourOptions).call(hourOptions, h => h < 12 && h > 0));
+      hourAdj = hour % 12 || 12;
+    } else {
+      hourOptionsAdj = hourOptions;
+      hourAdj = hour;
+    }
+
+    const transformHour = value => value + locale.hour;
+
+    const className = "".concat(prefixCls, "-list-hour");
+    return /*#__PURE__*/_react.default.createElement(_scrollItem.default, (0, _assign.default)({
+      ref: current => this.cacheRefCurrent('hour', current),
+      mode: 'wheel',
+      transform: transformHour,
+      cycled: true,
+      className: className,
+      list: (0, _map.default)(hourOptionsAdj).call(hourOptionsAdj, option => (0, _ComboxFoundation.formatOption)(option, disabledOptions)),
+      selectedIndex: (0, _indexOf.default)(hourOptionsAdj).call(hourOptionsAdj, hourAdj),
+      type: "hour",
+      onSelect: this.onItemChange
+    }, scrollItemProps));
+  }
+
+  renderMinuteSelect(minute, locale) {
+    const {
+      prefixCls,
+      disabledMinutes,
+      timeStampValue,
+      scrollItemProps
+    } = this.props;
+    const {
+      showMinute,
+      minuteOptions
+    } = this.state;
+
+    if (!showMinute) {
+      return null;
+    }
+
+    const value = new Date(timeStampValue);
+    const disabledOptions = disabledMinutes && disabledMinutes(value.getHours());
+    const className = "".concat(prefixCls, "-list-minute");
+
+    const transformMinute = min => min + locale.minute;
+
+    return /*#__PURE__*/_react.default.createElement(_scrollItem.default, (0, _assign.default)({
+      ref: current => this.cacheRefCurrent('minute', current),
+      mode: 'wheel',
+      transform: transformMinute,
+      cycled: true,
+      list: (0, _map.default)(minuteOptions).call(minuteOptions, option => (0, _ComboxFoundation.formatOption)(option, disabledOptions)),
+      selectedIndex: (0, _indexOf.default)(minuteOptions).call(minuteOptions, minute),
+      type: "minute",
+      onSelect: this.onItemChange,
+      className: className
+    }, scrollItemProps));
+  }
+
+  renderSecondSelect(second, locale) {
+    const {
+      prefixCls,
+      disabledSeconds,
+      timeStampValue,
+      scrollItemProps
+    } = this.props;
+    const {
+      showSecond,
+      secondOptions
+    } = this.state;
+
+    if (!showSecond) {
+      return null;
+    }
+
+    const value = new Date(timeStampValue);
+    const disabledOptions = disabledSeconds && disabledSeconds(value.getHours(), value.getMinutes());
+    const className = "".concat(prefixCls, "-list-second");
+
+    const transformSecond = sec => String(sec) + locale.second;
+
+    return /*#__PURE__*/_react.default.createElement(_scrollItem.default, (0, _assign.default)({
+      ref: current => this.cacheRefCurrent('second', current),
+      mode: 'wheel',
+      transform: transformSecond,
+      cycled: true,
+      list: (0, _map.default)(secondOptions).call(secondOptions, option => (0, _ComboxFoundation.formatOption)(option, disabledOptions)),
+      selectedIndex: (0, _indexOf.default)(secondOptions).call(secondOptions, second),
+      className: className,
+      type: "second",
+      onSelect: this.onItemChange
+    }, scrollItemProps));
+  }
+
+  renderAMPMSelect(locale, localeCode) {
+    const {
+      prefixCls,
+      use12Hours,
+      isAM,
+      scrollItemProps
+    } = this.props;
+
+    if (!use12Hours) {
+      return null;
+    }
+
+    const AMPMOptions = [{
+      value: 'AM',
+      text: locale.AM || '上午'
+    }, {
+      value: 'PM',
+      text: locale.PM || '下午'
+    }];
+    const selected = isAM ? 0 : 1;
+    const className = "".concat(prefixCls, "-list-ampm");
+    return /*#__PURE__*/_react.default.createElement(_scrollItem.default, (0, _assign.default)({
+      ref: current => this.cacheRefCurrent('ampm', current),
+      mode: 'wheel',
+      className: className,
+      cycled: false,
+      list: AMPMOptions,
+      selectedIndex: selected,
+      type: "ampm",
+      onSelect: this.onItemChange
+    }, scrollItemProps));
+  }
+
+  render() {
+    const {
+      timeStampValue,
+      panelHeader,
+      panelFooter
+    } = this.props;
+    const value = this.getDisplayDateFromTimeStamp(timeStampValue);
+    return /*#__PURE__*/_react.default.createElement(_localeConsumer.default, {
+      componentName: "TimePicker"
+    }, (locale, localeCode) => /*#__PURE__*/_react.default.createElement(_index.default, {
+      header: panelHeader,
+      footer: panelFooter
+    }, this.renderAMPMSelect(locale, localeCode), this.renderHourSelect(value.getHours(), locale), this.renderMinuteSelect(value.getMinutes(), locale), this.renderSecondSelect(value.getSeconds(), locale)));
+  }
+
+}
+
+Combobox.propTypes = {
+  format: _propTypes.default.string,
+  defaultOpenValue: _propTypes.default.object,
+  prefixCls: _propTypes.default.string,
+  onChange: _propTypes.default.func,
+  showHour: _propTypes.default.bool,
+  showMinute: _propTypes.default.bool,
+  showSecond: _propTypes.default.bool,
+  disabledHours: _propTypes.default.func,
+  disabledMinutes: _propTypes.default.func,
+  disabledSeconds: _propTypes.default.func,
+  hideDisabledOptions: _propTypes.default.bool,
+  onCurrentSelectPanelChange: _propTypes.default.func,
+  use12Hours: _propTypes.default.bool,
+  isAM: _propTypes.default.bool,
+  timeStampValue: _propTypes.default.any,
+  scrollItemProps: _propTypes.default.object
+};
+Combobox.defaultProps = {
+  disabledHours: _noop2.default,
+  disabledMinutes: _noop2.default,
+  disabledSeconds: _noop2.default,
+  format: _constants.strings.DEFAULT_FORMAT
+};
+var _default = Combobox;
+exports.default = _default;

package/lib/cjs/timePicker/PanelShape.d.ts

@@ -0,0 +1,6 @@
+import PropTypes from 'prop-types';
+export declare const PanelShape: {
+    panelHeader: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    panelFooter: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+};
+export declare const PanelShapeDefaults: {};

package/lib/cjs/timePicker/PanelShape.js

@@ -0,0 +1,21 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.PanelShapeDefaults = exports.PanelShape = void 0;
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+const PanelShape = {
+  panelHeader: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.string]),
+  panelFooter: _propTypes.default.oneOfType([_propTypes.default.node, _propTypes.default.string])
+};
+exports.PanelShape = PanelShape;
+const PanelShapeDefaults = {};
+exports.PanelShapeDefaults = PanelShapeDefaults;

package/lib/cjs/timePicker/TimeInput.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import BaseComponent, { BaseProps } from '../_base/baseComponent';
+import InputFoundation, { TimeInputAdapter } from '@douyinfe/semi-foundation/lib/cjs/timePicker/inputFoundation';
+import { TimePickerProps } from './TimePicker';
+export declare type TimeInputProps = Pick<TimePickerProps, 'value' | 'format' | 'prefixCls' | 'placeholder' | 'clearText' | 'inputReadOnly' | 'disabled' | 'type' | 'timeZone' | 'defaultOpen' | 'disabledHours' | 'disabledMinutes' | 'disabledSeconds' | 'dateFnsLocale' | 'onFocus' | 'onBlur' | 'focusOnOpen' | 'locale' | 'localeCode' | 'insetLabel' | 'validateStatus'> & BaseProps & {
+    onChange?: (value: string) => void;
+    onEsc?: () => void;
+    onClick?: React.MouseEventHandler;
+    defaultOpenValue?: boolean;
+    currentSelectPanel?: string;
+    timeStampValue?: any;
+    invalid?: boolean;
+};
+declare class TimeInput extends BaseComponent<TimeInputProps, any> {
+    static propTypes: {
+        format: PropTypes.Requireable<string>;
+        prefixCls: PropTypes.Requireable<string>;
+        placeholder: PropTypes.Requireable<string>;
+        clearText: PropTypes.Requireable<string>;
+        inputReadOnly: PropTypes.Requireable<boolean>;
+        hourOptions: PropTypes.Requireable<any[]>;
+        minuteOptions: PropTypes.Requireable<any[]>;
+        secondOptions: PropTypes.Requireable<any[]>;
+        disabledHours: PropTypes.Requireable<(...args: any[]) => any>;
+        disabledMinutes: PropTypes.Requireable<(...args: any[]) => any>;
+        disabledSeconds: PropTypes.Requireable<(...args: any[]) => any>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onFocus: PropTypes.Requireable<(...args: any[]) => any>;
+        onBlur: PropTypes.Requireable<(...args: any[]) => any>;
+        onEsc: PropTypes.Requireable<(...args: any[]) => any>;
+        onClick: PropTypes.Requireable<(...args: any[]) => any>;
+        defaultOpenValue: PropTypes.Requireable<object>;
+        currentSelectPanel: PropTypes.Requireable<string>;
+        focusOnOpen: PropTypes.Requireable<boolean>;
+        timeStampValue: PropTypes.Requireable<any>;
+        locale: PropTypes.Requireable<object>;
+        localeCode: PropTypes.Requireable<string>;
+        insetLabel: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        validateStatus: PropTypes.Requireable<string>;
+    };
+    static defaultProps: {
+        inputReadOnly: boolean;
+        onChange: (...args: any[]) => void;
+        onBlur: (...args: any[]) => void;
+        onFocus: (...args: any[]) => void;
+        onClick: (...args: any[]) => void;
+        disabledHours: (...args: any[]) => void;
+        disabledMinutes: (...args: any[]) => void;
+        disabledSeconds: (...args: any[]) => void;
+        format: string;
+    };
+    foundation: InputFoundation;
+    constructor(props: TimeInputProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: TimeInputProps): void;
+    get adapter(): TimeInputAdapter;
+    setRef: (node: HTMLElement) => void;
+    handleClick: React.MouseEventHandler;
+    handleFocus: React.FocusEventHandler;
+    handleBlur: React.FocusEventHandler;
+    handleChange: (v: string) => void;
+    getInput(): JSX.Element;
+    render(): JSX.Element;
+}
+export default TimeInput;

package/lib/cjs/timePicker/TimeInput.js

@@ -0,0 +1,226 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
+
+var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
+
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+
+exports.default = void 0;
+
+var _indexOf = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/index-of"));
+
+var _getOwnPropertySymbols = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/get-own-property-symbols"));
+
+var _setTimeout2 = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/set-timeout"));
+
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/assign"));
+
+var _noop2 = _interopRequireDefault(require("lodash/noop"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _propTypes = _interopRequireDefault(require("prop-types"));
+
+var _classnames = _interopRequireDefault(require("classnames"));
+
+var _constants = require("@douyinfe/semi-foundation/lib/cjs/timePicker/constants");
+
+var _input = _interopRequireDefault(require("../input"));
+
+var _baseComponent = _interopRequireDefault(require("../_base/baseComponent"));
+
+var _inputFoundation = _interopRequireDefault(require("@douyinfe/semi-foundation/lib/cjs/timePicker/inputFoundation"));
+
+var _semiIcons = require("@douyinfe/semi-icons");
+
+var __rest = void 0 && (void 0).__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && (0, _indexOf.default)(e).call(e, p) < 0) t[p] = s[p];
+
+  if (s != null && typeof _getOwnPropertySymbols.default === "function") for (var i = 0, p = (0, _getOwnPropertySymbols.default)(s); i < p.length; i++) {
+    if ((0, _indexOf.default)(e).call(e, p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+};
+/* eslint-disable no-unused-vars */
+
+
+class TimeInput extends _baseComponent.default {
+  constructor(props) {
+    super(props);
+
+    this.setRef = node => this.adapter.setCache('inputNode', node);
+
+    this.handleClick = e => this.props.onClick(e);
+
+    this.handleFocus = e => this.foundation.handleFocus(e);
+
+    this.handleBlur = e => this.foundation.handleBlur(e);
+
+    this.handleChange = v => this.foundation.handleChange(v);
+
+    this.foundation = new _inputFoundation.default(this.adapter);
+    this.state = {// focusing: props.focusOnOpen,
+    };
+  }
+
+  componentDidMount() {
+    super.componentDidMount();
+    const {
+      focusOnOpen
+    } = this.props;
+
+    if (focusOnOpen) {
+      const requestAnimationFrame = window.requestAnimationFrame || _setTimeout2.default;
+      requestAnimationFrame(() => {
+        const inputNode = this.adapter.getCache('inputNode');
+
+        if (inputNode) {
+          inputNode.focus();
+          inputNode.select();
+        }
+      });
+    }
+  }
+
+  componentDidUpdate(prevProps) {
+    const {
+      timeStampValue
+    } = this.props;
+
+    if (this.isControlled('timeStampValue') && timeStampValue !== this.state.timeStampValue) {
+      this.foundation.restoreCursor();
+    }
+
+    if (this.props.value !== prevProps.value) {
+      this.foundation.restoreCursor();
+    }
+  }
+
+  get adapter() {
+    var _this = this;
+
+    return (0, _assign.default)((0, _assign.default)({}, super.adapter), {
+      notifyChange: function () {
+        return _this.props.onChange(...arguments);
+      },
+      notifyFocus: function () {
+        return _this.props.onFocus(...arguments);
+      },
+      notifyBlur: function () {
+        return _this.props.onBlur(...arguments);
+      }
+    });
+  }
+
+  getInput() {
+    const _a = this.props,
+          {
+      prefixCls,
+      placeholder,
+      inputReadOnly,
+      onFocus,
+      disabled,
+      type,
+      locale,
+      localeCode,
+      insetLabel,
+      validateStatus,
+      value,
+      onChange,
+      invalid,
+      format,
+      clearText,
+      disabledHours,
+      disabledMinutes,
+      disabledSeconds,
+      onEsc,
+      defaultOpenValue,
+      currentSelectPanel,
+      focusOnOpen,
+      timeStampValue,
+      timeZone,
+      defaultOpen,
+      dateFnsLocale
+    } = _a,
+          rest = __rest(_a, ["prefixCls", "placeholder", "inputReadOnly", "onFocus", "disabled", "type", "locale", "localeCode", "insetLabel", "validateStatus", "value", "onChange", "invalid", "format", "clearText", "disabledHours", "disabledMinutes", "disabledSeconds", "onEsc", "defaultOpenValue", "currentSelectPanel", "focusOnOpen", "timeStampValue", "timeZone", "defaultOpen", "dateFnsLocale"]); // const { focusing } = this.state;
+
+
+    const inputCls = (0, _classnames.default)("".concat(prefixCls, "-input"), {
+      ["".concat(prefixCls, "-input-invalid")]: invalid,
+      ["".concat(prefixCls, "-input-readonly")]: inputReadOnly
+    });
+    const mergeValidateStatus = invalid ? 'error' : validateStatus;
+    return /*#__PURE__*/_react.default.createElement(_input.default, (0, _assign.default)({}, rest, {
+      hideSuffix: true,
+      className: inputCls,
+      ref: this.setRef,
+      value: value,
+      placeholder: placeholder || locale.placeholder[type],
+      readonly: Boolean(inputReadOnly),
+      onChange: this.handleChange,
+      onFocus: this.handleFocus,
+      onBlur: this.handleBlur,
+      suffix: /*#__PURE__*/_react.default.createElement(_semiIcons.IconClock, {
+        onClick: this.handleClick
+      }),
+      validateStatus: mergeValidateStatus,
+      disabled: disabled,
+      insetLabel: insetLabel
+    }));
+  }
+
+  render() {
+    const {
+      prefixCls
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement("div", {
+      className: "".concat(prefixCls, "-input-wrap")
+    }, this.getInput());
+  }
+
+}
+
+TimeInput.propTypes = {
+  format: _propTypes.default.string,
+  prefixCls: _propTypes.default.string,
+  placeholder: _propTypes.default.string,
+  clearText: _propTypes.default.string,
+  inputReadOnly: _propTypes.default.bool,
+  hourOptions: _propTypes.default.array,
+  minuteOptions: _propTypes.default.array,
+  secondOptions: _propTypes.default.array,
+  disabledHours: _propTypes.default.func,
+  disabledMinutes: _propTypes.default.func,
+  disabledSeconds: _propTypes.default.func,
+  onChange: _propTypes.default.func,
+  onFocus: _propTypes.default.func,
+  onBlur: _propTypes.default.func,
+  onEsc: _propTypes.default.func,
+  onClick: _propTypes.default.func,
+  defaultOpenValue: _propTypes.default.object,
+  currentSelectPanel: _propTypes.default.string,
+  focusOnOpen: _propTypes.default.bool,
+  timeStampValue: _propTypes.default.any,
+  locale: _propTypes.default.object,
+  localeCode: _propTypes.default.string,
+  insetLabel: _propTypes.default.node,
+  validateStatus: _propTypes.default.string
+};
+TimeInput.defaultProps = {
+  inputReadOnly: false,
+  onChange: _noop2.default,
+  onBlur: _noop2.default,
+  onFocus: _noop2.default,
+  onClick: _noop2.default,
+  disabledHours: _noop2.default,
+  disabledMinutes: _noop2.default,
+  disabledSeconds: _noop2.default,
+  format: _constants.strings.DEFAULT_FORMAT
+};
+var _default = TimeInput;
+exports.default = _default;