@jetbrains/ring-ui-built 6.0.1

package/components/date-picker/date-popup.d.ts

@@ -0,0 +1,55 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { DatePickerChange, DatePopupBaseProps, DateSpecificPopupProps, DatePopupState, RangeSpecificPopupProps, TimeSpecificPopupProps, Field } from './consts';
+export type DatePopupProps = DatePopupBaseProps & (DateSpecificPopupProps | TimeSpecificPopupProps | RangeSpecificPopupProps);
+export default class DatePopup extends Component<DatePopupProps, DatePopupState> {
+    static sameDay(next: Date | number | null, prev: Date | number | null): boolean;
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        date: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        range: PropTypes.Requireable<boolean>;
+        withTime: PropTypes.Requireable<boolean>;
+        time: PropTypes.Requireable<string>;
+        from: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        to: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        renderAfterCalendar: PropTypes.Requireable<(...args: any[]) => any>;
+        displayFormat: PropTypes.Requireable<(...args: any[]) => any>;
+        parseDateInput: PropTypes.Requireable<(...args: any[]) => any>;
+        onChange: PropTypes.Requireable<(...args: any[]) => any>;
+        onComplete: PropTypes.Requireable<(...args: any[]) => any>;
+        onClear: PropTypes.Requireable<(...args: any[]) => any>;
+        minDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        maxDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        fromPlaceholder: PropTypes.Requireable<string>;
+        toPlaceholder: PropTypes.Requireable<string>;
+        timePlaceholder: PropTypes.Requireable<string>;
+        locale: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        onChange(): void;
+    };
+    constructor(props: DatePopupProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: DatePopupBaseProps, prevState: DatePopupState): void;
+    componentWillUnmount(): void;
+    private _scrollDate?;
+    private _scrollTS?;
+    isInTimeMode: () => boolean;
+    componentRef: React.RefObject<HTMLDivElement>;
+    handleWheel: (e: WheelEvent) => void;
+    parse(text: string | null | undefined, type: 'time'): string;
+    parse(text: Date | number | string | null | undefined, type?: 'date' | 'from' | 'to'): Date;
+    select(changes: DatePickerChange): void;
+    confirm(name: Field): void;
+    isValidDate: (parsedText: Date) => boolean;
+    scheduleScroll: () => void;
+    scrollTo: (scrollDate: number) => void;
+    hoverHandler: (hoverDate: Date) => void;
+    handleActivate: (arg: Field) => () => void;
+    handleInput: (text: string, name: Field) => void;
+    handleConfirm: (arg: Field) => () => void;
+    selectHandler: (date: Date) => void;
+    handleScroll: (scrollDate: number) => void;
+    onClear: (e: React.MouseEvent<HTMLButtonElement>) => void;
+    render(): React.JSX.Element;
+}

package/components/date-picker/date-popup.js

@@ -0,0 +1,488 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, k as _assertThisInitialized, g as _objectSpread2, d as _createClass, e as _objectWithoutProperties, f as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.array.map.js';
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import isAfter from 'date-fns/isAfter';
+import isBefore from 'date-fns/isBefore';
+import isSameDay from 'date-fns/isSameDay';
+import startOfDay from 'date-fns/startOfDay';
+import { set } from 'date-fns';
+import memoize from '../global/memoize.js';
+import DateInput from './date-input.js';
+import Months from './months.js';
+import Years from './years.js';
+import Weekdays from './weekdays.js';
+import { dateType, parseTime } from './consts.js';
+import { m as modules_0c7b7d96 } from '../_helpers/date-picker.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.array.filter.js';
+import 'classnames';
+import '../_helpers/input.js';
+import 'core-js/modules/es.object.values.js';
+import '@jetbrains/icons/close-12px';
+import '../global/prop-types.js';
+import '../button/button.js';
+import '@jetbrains/icons/chevron-10px';
+import '../icon/icon.js';
+import 'util-deprecate';
+import '../icon/icon__constants.js';
+import '../_helpers/icon__svg.js';
+import 'core-js/modules/es.string.starts-with.js';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../i18n/i18n-context.js';
+import '../i18n/i18n.js';
+import 'core-js/modules/es.set.js';
+import '../global/composeRefs.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import '../control-label/control-label.js';
+import 'date-fns/addMonths';
+import 'date-fns/getDay';
+import 'date-fns/getDaysInMonth';
+import 'date-fns/startOfMonth';
+import 'date-fns/subMonths';
+import 'date-fns/endOfMonth';
+import '../global/schedule-raf.js';
+import '../global/linear-function.js';
+import '../global/use-event-callback.js';
+import './month.js';
+import 'date-fns/addDays';
+import 'date-fns/format';
+import 'date-fns/setDay';
+import './day.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'date-fns/getDate';
+import 'date-fns/isToday';
+import 'date-fns/add';
+import './month-names.js';
+import 'date-fns/isThisMonth';
+import 'date-fns/set';
+import 'date-fns/startOfYear';
+import './month-slider.js';
+import 'date-fns/addYears';
+import 'date-fns/subYears';
+import 'date-fns/getYear';
+import 'date-fns/isSameYear';
+import 'date-fns/isThisYear';
+import 'date-fns/setYear';
+
+var _excluded = ["from", "to", "date", "time"];
+var scrollExpDelay = 10;
+var DatePopup = /*#__PURE__*/function (_Component) {
+  _inherits(DatePopup, _Component);
+  var _super = _createSuper(DatePopup);
+  function DatePopup(props) {
+    var _this;
+    _classCallCheck(this, DatePopup);
+    _this = _super.call(this, props);
+    _defineProperty(_assertThisInitialized(_this), "_scrollDate", void 0);
+    _defineProperty(_assertThisInitialized(_this), "_scrollTS", void 0);
+    _defineProperty(_assertThisInitialized(_this), "isInTimeMode", function () {
+      return !_this.props.range && _this.props.withTime || false;
+    });
+    _defineProperty(_assertThisInitialized(_this), "componentRef", /*#__PURE__*/React.createRef());
+    _defineProperty(_assertThisInitialized(_this), "handleWheel", function (e) {
+      if (e.cancelable) {
+        e.preventDefault();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "isValidDate", function (parsedText) {
+      var minDate = _this.parse(_this.props.minDate, 'date');
+      var maxDate = _this.parse(_this.props.maxDate, 'date');
+      if (parsedText) {
+        return !(minDate && isBefore(parsedText, minDate) || maxDate && isAfter(parsedText, maxDate));
+      }
+      return false;
+    });
+    _defineProperty(_assertThisInitialized(_this), "scheduleScroll", function () {
+      var current = _this.state.scrollDate && _this.parse(_this.state.scrollDate, 'date') || _this.parse(_this.props[_this.state.active], 'date') || new Date();
+      var goal = _this._scrollDate;
+      if (!current || !goal || DatePopup.sameDay(goal, current)) {
+        _this._scrollDate = null;
+        _this._scrollTS = null;
+        return;
+      }
+      if (_this._scrollTS) {
+        var diff = goal - Number(current);
+        var dt = Date.now() - _this._scrollTS;
+        var next = goal - diff * Math.pow(Math.E, -dt / scrollExpDelay);
+        _this.setState({
+          scrollDate: next
+        });
+      }
+      _this._scrollTS = Date.now();
+      window.requestAnimationFrame(_this.scheduleScroll);
+    });
+    _defineProperty(_assertThisInitialized(_this), "scrollTo", function (scrollDate) {
+      _this._scrollDate = scrollDate;
+      if (!_this._scrollTS) {
+        _this.scheduleScroll();
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "hoverHandler", function (hoverDate) {
+      return _this.setState({
+        hoverDate
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleActivate", memoize(function (name) {
+      return function () {
+        return _this.setState({
+          active: name
+        });
+      };
+    }));
+    _defineProperty(_assertThisInitialized(_this), "handleInput", function (text, name) {
+      if (name !== 'time') {
+        var parsed = _this.parse(text, name);
+        if (_this.isValidDate(parsed)) {
+          _this.scrollTo(Number(parsed));
+        }
+      }
+      _this.setState({
+        text,
+        hoverDate: null
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleConfirm", memoize(function (name) {
+      return function () {
+        return _this.confirm(name);
+      };
+    }));
+    _defineProperty(_assertThisInitialized(_this), "selectHandler", function (date) {
+      if (_this.isInTimeMode()) {
+        _this.setState({
+          active: 'time'
+        }, function () {
+          return _this.select({
+            date
+          });
+        });
+      } else {
+        _this.select({
+          [_this.state.active]: date
+        });
+      }
+    });
+    _defineProperty(_assertThisInitialized(_this), "handleScroll", function (scrollDate) {
+      return _this.setState({
+        scrollDate
+      });
+    });
+    _defineProperty(_assertThisInitialized(_this), "onClear", function (e) {
+      var _this$props$onClear, _this$props, _this$componentRef$cu;
+      var changes;
+      if (_this.props.range) {
+        changes = {
+          from: null,
+          to: null
+        };
+      } else {
+        changes = {
+          date: null
+        };
+      }
+      _this.select(changes);
+      (_this$props$onClear = (_this$props = _this.props).onClear) === null || _this$props$onClear === void 0 || _this$props$onClear.call(_this$props, e);
+      (_this$componentRef$cu = _this.componentRef.current) === null || _this$componentRef$cu === void 0 || (_this$componentRef$cu = _this$componentRef$cu.querySelector('input')) === null || _this$componentRef$cu === void 0 || _this$componentRef$cu.focus();
+    });
+    var defaultState = {
+      text: null,
+      hoverDate: null,
+      scrollDate: null
+    };
+    var range = props.range,
+      withTime = props.withTime;
+    if (!range) {
+      var parsedDate = _this.parse(props.date, 'date');
+      var active = withTime && parsedDate && !props.time ? 'time' : 'date';
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active
+      });
+    } else if (props.from && !props.to) {
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active: 'to'
+      });
+    } else {
+      _this.state = _objectSpread2(_objectSpread2({}, defaultState), {}, {
+        active: 'from'
+      });
+    }
+    return _this;
+  }
+  _createClass(DatePopup, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (this.componentRef.current) {
+        this.componentRef.current.addEventListener('wheel', this.handleWheel);
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (this.state.active !== prevState.active) {
+        if (this.state.text && prevState.active) {
+          this.confirm(prevState.active);
+        }
+        this.setState({
+          text: null
+        });
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.componentRef.current) {
+        this.componentRef.current.removeEventListener('wheel', this.handleWheel);
+      }
+    }
+  }, {
+    key: "parse",
+    value: function parse(text, type) {
+      if (type === 'time') {
+        return parseTime(String(text));
+      }
+      return this.props.parseDateInput(text);
+    }
+  }, {
+    key: "select",
+    value: function select(changes) {
+      var _this$props2 = this.props,
+        range = _this$props2.range,
+        withTime = _this$props2.withTime;
+      var prevActive = this.state.active;
+      if (!range && !withTime) {
+        this.setState({
+          text: null,
+          scrollDate: null
+        });
+        var adjustedDate = changes.date && set(new Date(), {
+          year: changes.date.getFullYear(),
+          month: changes.date.getMonth(),
+          date: changes.date.getDate()
+        });
+        this.props.onChange(adjustedDate);
+        this.props.onComplete();
+      } else if (!range && withTime) {
+        var date = this.parse(this.props.date, 'date');
+        var time = this.parse(this.props.time, 'time');
+        var changeToSubmit = {
+          date: changes.date || date,
+          time: changes.time || time
+        };
+        this.setState({
+          active: changes.date ? 'time' : 'date',
+          text: null,
+          scrollDate: null
+        });
+        this.props.onChange(changeToSubmit);
+        if (!changes.date && prevActive === 'time' && changeToSubmit.date && changeToSubmit.time) {
+          this.props.onComplete();
+        }
+      } else {
+        var _this$props$changes = _objectSpread2(_objectSpread2({}, this.props), changes),
+          from = _this$props$changes.from,
+          to = _this$props$changes.to;
+        from = this.parse(from, 'from');
+        to = this.parse(to, 'to');
+        // proceed to setting the end by default
+        var active = 'to';
+        var complete = false;
+        // end is before beginning
+        if (from && to && isAfter(startOfDay(from), startOfDay(to))) {
+          // ignore the old end when beginning is changed
+          if (changes.from) {
+            to = null;
+            // treat range as reverse when end is changed
+          } else if (changes.to) {
+            to = from;
+            from = changes.to;
+          }
+        } else if (changes.to) {
+          active = 'from';
+          complete = !!from;
+        }
+        this.setState({
+          active,
+          hoverDate: null,
+          text: null
+        });
+        this.props.onChange({
+          from,
+          to
+        });
+        if (complete) {
+          this.props.onComplete();
+        }
+      }
+    }
+  }, {
+    key: "confirm",
+    value: function confirm(name) {
+      var text = this.state.text;
+      var result;
+      if (name === 'time') {
+        result = this.parse(text, name);
+        var time = this.parse('time' in this.props ? this.props.time : '', 'time');
+        var emptyCase = this.state.active === 'time' ? '00:00' : null;
+        result = result || time || emptyCase;
+      } else {
+        result = this.parse(text, name);
+        if (!this.isValidDate(result)) {
+          result = this.parse(name in this.props ? this.props[name] : '', name);
+        }
+      }
+      this.select({
+        [name]: result
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props3 = this.props,
+        range = _this$props3.range,
+        withTime = _this$props3.withTime,
+        locale = _this$props3.locale;
+      var _this$props4 = this.props;
+        _this$props4.from;
+        _this$props4.to;
+        _this$props4.date;
+        var time = _this$props4.time,
+        restProps = _objectWithoutProperties(_this$props4, _excluded);
+      var parsedDate = this.parse(this.props.date, 'date');
+      var parsedTo = this.parse(this.props.to, 'to');
+      var names = range ? ['from', 'to'] : ['date'];
+      var dates = names.reduce(function (obj, key) {
+        var value = _this2.props[key];
+        return _objectSpread2(_objectSpread2({}, obj), {}, {
+          [key]: _this2.parse(value, key)
+        });
+      }, {});
+      var activeDate = this.state.active !== 'time' ? this.state.hoverDate || (this.state.text != null ? this.parse(this.state.text, 'date') : null) : this.state.hoverDate || null;
+      var currentRange = range && dates.from && dates.to && [dates.from, dates.to] || null;
+      var activeRange = null;
+      if (range && activeDate) {
+        switch (this.state.active) {
+          case 'from':
+            if (dates.to && isAfter(startOfDay(activeDate), startOfDay(dates.to))) {
+              activeRange = [activeDate, dates.to];
+            }
+            break;
+          case 'to':
+            if (!dates.from) {
+              break;
+            }
+            if (isBefore(startOfDay(activeDate), startOfDay(dates.from))) {
+              activeRange = [activeDate, dates.from];
+            } else {
+              activeRange = [dates.from, activeDate];
+            }
+            break;
+        }
+      }
+      var scrollDate = withTime && !range ? this.state.scrollDate || dates.date || new Date() : this.state.scrollDate || dates[this.state.active] || new Date();
+      var calendarProps = _objectSpread2(_objectSpread2(_objectSpread2({}, restProps), dates), {}, {
+        scrollDate,
+        activeDate,
+        currentRange,
+        activeRange,
+        onScroll: this.handleScroll,
+        onScrollChange: this.scrollTo
+      });
+      var clearable = Boolean(this.props.onClear);
+      return /*#__PURE__*/React.createElement("div", {
+        className: modules_0c7b7d96.datePopup,
+        "data-test": "ring-date-popup",
+        ref: this.componentRef
+      }, /*#__PURE__*/React.createElement("div", {
+        className: modules_0c7b7d96.filterWrapper
+      }, names.map(function (name) {
+        var onClear;
+        if (clearable && name !== 'from' && !_this2.isInTimeMode()) {
+          onClear = _this2.onClear.bind(_this2);
+        }
+        return /*#__PURE__*/React.createElement(DateInput, _extends({}, _this2.props, _this2.state, {
+          divider: name === 'from' && (dates[name] != null || parsedTo != null),
+          name: name,
+          key: name,
+          date: dates[name],
+          active: _this2.state.active === name,
+          onActivate: _this2.handleActivate(name),
+          onInput: _this2.handleInput,
+          onConfirm: _this2.handleConfirm(name),
+          onClear: onClear,
+          locale: locale
+        }));
+      }), this.isInTimeMode() ? /*#__PURE__*/React.createElement(DateInput, _extends({}, this.props, {
+        text: this.state.text,
+        divider: !!parsedDate,
+        hoverDate: null,
+        name: 'time',
+        key: 'time',
+        date: null,
+        time: time,
+        active: this.state.active === 'time',
+        onActivate: this.handleActivate('time'),
+        onInput: this.handleInput,
+        onConfirm: this.handleConfirm('time'),
+        onClear: clearable && this.onClear || undefined,
+        locale: locale
+      })) : ''), /*#__PURE__*/React.createElement(Weekdays, {
+        locale: locale
+      }), /*#__PURE__*/React.createElement("div", {
+        className: modules_0c7b7d96.calendar
+      }, /*#__PURE__*/React.createElement(Months, _extends({}, calendarProps, {
+        onHover: this.hoverHandler,
+        onSelect: this.selectHandler,
+        locale: locale
+      })), /*#__PURE__*/React.createElement(Years, calendarProps)), this.props.renderAfterCalendar && this.props.renderAfterCalendar(this.state));
+    }
+  }], [{
+    key: "sameDay",
+    value: function sameDay(next, prev) {
+      if (next && prev) {
+        return isSameDay(next, prev);
+      }
+      return next === prev;
+    }
+  }]);
+  return DatePopup;
+}(Component);
+_defineProperty(DatePopup, "propTypes", {
+  className: PropTypes.string,
+  date: dateType,
+  range: PropTypes.bool,
+  withTime: PropTypes.bool,
+  time: PropTypes.string,
+  from: dateType,
+  to: dateType,
+  renderAfterCalendar: PropTypes.func,
+  displayFormat: PropTypes.func,
+  parseDateInput: PropTypes.func,
+  onChange: PropTypes.func,
+  onComplete: PropTypes.func,
+  onClear: PropTypes.func,
+  minDate: dateType,
+  maxDate: dateType,
+  fromPlaceholder: PropTypes.string,
+  toPlaceholder: PropTypes.string,
+  timePlaceholder: PropTypes.string,
+  locale: PropTypes.object
+});
+_defineProperty(DatePopup, "defaultProps", {
+  onChange() {}
+});
+
+export { DatePopup as default };

package/components/date-picker/day.d.ts

@@ -0,0 +1,30 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { MonthsProps } from './consts';
+export interface DayProps extends MonthsProps {
+    day: Date;
+    empty: boolean;
+}
+export default class Day extends Component<DayProps> {
+    static propTypes: {
+        day: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        from: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        currentRange: PropTypes.Requireable<(NonNullable<string | number | Date | null | undefined> | null | undefined)[]>;
+        activeRange: PropTypes.Requireable<(NonNullable<string | number | Date | null | undefined> | null | undefined)[]>;
+        empty: PropTypes.Requireable<boolean>;
+        onSelect: PropTypes.Requireable<(...args: any[]) => any>;
+        parseDateInput: PropTypes.Requireable<(...args: any[]) => any>;
+        onHover: PropTypes.Requireable<(...args: any[]) => any>;
+        minDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+        maxDate: PropTypes.Requireable<NonNullable<string | number | Date | null | undefined>>;
+    };
+    handleClick: () => void;
+    handleMouseOver: () => void;
+    handleMouseOut: () => void;
+    isDay: (date: Date) => boolean;
+    is: (name: 'date' | 'from' | 'to' | 'activeDate') => boolean;
+    inRange: (range: [Date, Date] | null) => boolean | null;
+    isDisabled: (date: Date) => boolean;
+    parse(text: string | null | undefined): Date | null;
+    render(): React.JSX.Element;
+}