@i-novus/n2o-components 1.0.0

package/lib/inputs/DatePicker/PopUp.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PopUp = exports.PopUpComponent = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactOnclickoutside = _interopRequireDefault(require("react-onclickoutside"));
+
+var _reactI18next = require("react-i18next");
+
+var _Calendar = require("./Calendar");
+
+var _excluded = ["hasDefaultTime"];
+
+var PopUpComponent = function PopUpComponent(_ref) {
+  var dateFormat = _ref.dateFormat,
+      markTimeAsSet = _ref.markTimeAsSet,
+      timeFormat = _ref.timeFormat,
+      value = _ref.value,
+      max = _ref.max,
+      min = _ref.min,
+      locale = _ref.locale,
+      select = _ref.select,
+      time = _ref.time,
+      isTimeSet = _ref.isTimeSet,
+      type = _ref.type;
+
+  var _useTranslation = (0, _reactI18next.useTranslation)(),
+      t = _useTranslation.t;
+
+  return /*#__PURE__*/_react["default"].createElement("div", {
+    className: "d-inline-flex justify-content-end"
+  }, Object.keys(value).map(function (input, i) {
+    var _time$input = time[input],
+        hasDefaultTime = _time$input.hasDefaultTime,
+        timeObj = (0, _objectWithoutProperties2["default"])(_time$input, _excluded);
+    return /*#__PURE__*/_react["default"].createElement(_Calendar.Calendar
+    /* eslint-disable react/no-array-index-key */
+    , {
+      key: i,
+      index: i,
+      values: value,
+      type: type,
+      time: timeObj,
+      markTimeAsSet: markTimeAsSet,
+      hasDefaultTime: hasDefaultTime || isTimeSet[input],
+      inputName: input,
+      value: value[input],
+      timeFormat: timeFormat,
+      select: select,
+      max: max,
+      min: min,
+      locale: locale,
+      dateFormat: dateFormat,
+      t: t
+    });
+  }));
+};
+
+exports.PopUpComponent = PopUpComponent;
+PopUpComponent.prototype = {};
+var PopUp = (0, _reactOnclickoutside["default"])(PopUpComponent);
+exports.PopUp = PopUp;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pbnB1dHMvRGF0ZVBpY2tlci9Qb3BVcC50c3giXSwibmFtZXMiOlsiUG9wVXBDb21wb25lbnQiLCJkYXRlRm9ybWF0IiwibWFya1RpbWVBc1NldCIsInRpbWVGb3JtYXQiLCJ2YWx1ZSIsIm1heCIsIm1pbiIsImxvY2FsZSIsInNlbGVjdCIsInRpbWUiLCJpc1RpbWVTZXQiLCJ0eXBlIiwidCIsIk9iamVjdCIsImtleXMiLCJtYXAiLCJpbnB1dCIsImkiLCJoYXNEZWZhdWx0VGltZSIsInRpbWVPYmoiLCJwcm90b3R5cGUiLCJQb3BVcCJdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFBQTs7QUFFQTs7QUFDQTs7QUFFQTs7OztBQWlCTyxJQUFNQSxjQUFjLEdBQUcsU0FBakJBLGNBQWlCLE9BWVo7QUFBQSxNQVhkQyxVQVdjLFFBWGRBLFVBV2M7QUFBQSxNQVZkQyxhQVVjLFFBVmRBLGFBVWM7QUFBQSxNQVRkQyxVQVNjLFFBVGRBLFVBU2M7QUFBQSxNQVJkQyxLQVFjLFFBUmRBLEtBUWM7QUFBQSxNQVBkQyxHQU9jLFFBUGRBLEdBT2M7QUFBQSxNQU5kQyxHQU1jLFFBTmRBLEdBTWM7QUFBQSxNQUxkQyxNQUtjLFFBTGRBLE1BS2M7QUFBQSxNQUpkQyxNQUljLFFBSmRBLE1BSWM7QUFBQSxNQUhkQyxJQUdjLFFBSGRBLElBR2M7QUFBQSxNQUZkQyxTQUVjLFFBRmRBLFNBRWM7QUFBQSxNQURkQyxJQUNjLFFBRGRBLElBQ2M7O0FBQ2Qsd0JBQWMsbUNBQWQ7QUFBQSxNQUFRQyxDQUFSLG1CQUFRQSxDQUFSOztBQUVBLHNCQUNJO0FBQUssSUFBQSxTQUFTLEVBQUM7QUFBZixLQUNLQyxNQUFNLENBQUNDLElBQVAsQ0FBWVYsS0FBWixFQUFtQlcsR0FBbkIsQ0FBdUIsVUFBQ0MsS0FBRCxFQUFRQyxDQUFSLEVBQWM7QUFDbEMsc0JBQXVDUixJQUFJLENBQUNPLEtBQUQsQ0FBM0M7QUFBQSxRQUFRRSxjQUFSLGVBQVFBLGNBQVI7QUFBQSxRQUEyQkMsT0FBM0I7QUFFQSx3QkFDSSxnQ0FBQztBQUNHO0FBREo7QUFFSSxNQUFBLEdBQUcsRUFBRUYsQ0FGVDtBQUdJLE1BQUEsS0FBSyxFQUFFQSxDQUhYO0FBSUksTUFBQSxNQUFNLEVBQUViLEtBSlo7QUFLSSxNQUFBLElBQUksRUFBRU8sSUFMVjtBQU1JLE1BQUEsSUFBSSxFQUFFUSxPQU5WO0FBT0ksTUFBQSxhQUFhLEVBQUVqQixhQVBuQjtBQVFJLE1BQUEsY0FBYyxFQUFFZ0IsY0FBYyxJQUFJUixTQUFTLENBQUNNLEtBQUQsQ0FSL0M7QUFTSSxNQUFBLFNBQVMsRUFBRUEsS0FUZjtBQVVJLE1BQUEsS0FBSyxFQUFFWixLQUFLLENBQUNZLEtBQUQsQ0FWaEI7QUFXSSxNQUFBLFVBQVUsRUFBRWIsVUFYaEI7QUFZSSxNQUFBLE1BQU0sRUFBRUssTUFaWjtBQWFJLE1BQUEsR0FBRyxFQUFFSCxHQWJUO0FBY0ksTUFBQSxHQUFHLEVBQUVDLEdBZFQ7QUFlSSxNQUFBLE1BQU0sRUFBRUMsTUFmWjtBQWdCSSxNQUFBLFVBQVUsRUFBRU4sVUFoQmhCO0FBaUJJLE1BQUEsQ0FBQyxFQUFFVztBQWpCUCxNQURKO0FBcUJILEdBeEJBLENBREwsQ0FESjtBQTZCSCxDQTVDTTs7O0FBOENQWixjQUFjLENBQUNvQixTQUFmLEdBQTJCLEVBQTNCO0FBRU8sSUFBTUMsS0FBSyxHQUFHLHFDQUFlckIsY0FBZixDQUFkIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgTW9tZW50IH0gZnJvbSAnbW9tZW50L21vbWVudCdcbmltcG9ydCBvbkNsaWNrT3V0c2lkZSBmcm9tICdyZWFjdC1vbmNsaWNrb3V0c2lkZSdcbmltcG9ydCB7IHVzZVRyYW5zbGF0aW9uIH0gZnJvbSAncmVhY3QtaTE4bmV4dCdcblxuaW1wb3J0IHsgQ2FsZW5kYXIgfSBmcm9tICcuL0NhbGVuZGFyJ1xuaW1wb3J0IHsgVGltZSwgRGVmYXVsdFRpbWUgfSBmcm9tICcuL3R5cGVzJ1xuXG50eXBlIFBvcFVwUHJvcHMgPSB7XG4gICAgZGF0ZUZvcm1hdDogc3RyaW5nLFxuICAgIGlzVGltZVNldDogUmVjb3JkPHN0cmluZywgYm9vbGVhbiB8IHVuZGVmaW5lZD4sXG4gICAgbG9jYWxlOiAnZW4nIHwgJ3J1JyxcbiAgICBtYXJrVGltZUFzU2V0KHN0cjogc3RyaW5nKTogdm9pZCxcbiAgICBtYXg/OiBNb21lbnQgfCBEYXRlIHwgc3RyaW5nLFxuICAgIG1pbj86IE1vbWVudCB8IERhdGUgfCBzdHJpbmcsXG4gICAgc2VsZWN0KGRheTogTW9tZW50IHwgbnVsbCwgaW5wdXROYW1lOiBzdHJpbmcsIGNsb3NlPzogYm9vbGVhbik6IHZvaWQsXG4gICAgdGltZTogRGVmYXVsdFRpbWUsXG4gICAgdGltZUZvcm1hdD86IHN0cmluZyxcbiAgICB0eXBlPzogc3RyaW5nLFxuICAgIHZhbHVlOiBSZWNvcmQ8c3RyaW5nLCBNb21lbnQgfCBudWxsPlxufVxuXG5leHBvcnQgY29uc3QgUG9wVXBDb21wb25lbnQgPSAoe1xuICAgIGRhdGVGb3JtYXQsXG4gICAgbWFya1RpbWVBc1NldCxcbiAgICB0aW1lRm9ybWF0LFxuICAgIHZhbHVlLFxuICAgIG1heCxcbiAgICBtaW4sXG4gICAgbG9jYWxlLFxuICAgIHNlbGVjdCxcbiAgICB0aW1lLFxuICAgIGlzVGltZVNldCxcbiAgICB0eXBlLFxufTogUG9wVXBQcm9wcykgPT4ge1xuICAgIGNvbnN0IHsgdCB9ID0gdXNlVHJhbnNsYXRpb24oKVxuXG4gICAgcmV0dXJuIChcbiAgICAgICAgPGRpdiBjbGFzc05hbWU9XCJkLWlubGluZS1mbGV4IGp1c3RpZnktY29udGVudC1lbmRcIj5cbiAgICAgICAgICAgIHtPYmplY3Qua2V5cyh2YWx1ZSkubWFwKChpbnB1dCwgaSkgPT4ge1xuICAgICAgICAgICAgICAgIGNvbnN0IHsgaGFzRGVmYXVsdFRpbWUsIC4uLnRpbWVPYmogfSA9IHRpbWVbaW5wdXRdXG5cbiAgICAgICAgICAgICAgICByZXR1cm4gKFxuICAgICAgICAgICAgICAgICAgICA8Q2FsZW5kYXJcbiAgICAgICAgICAgICAgICAgICAgICAgIC8qIGVzbGludC1kaXNhYmxlIHJlYWN0L25vLWFycmF5LWluZGV4LWtleSAqL1xuICAgICAgICAgICAgICAgICAgICAgICAga2V5PXtpfVxuICAgICAgICAgICAgICAgICAgICAgICAgaW5kZXg9e2l9XG4gICAgICAgICAgICAgICAgICAgICAgICB2YWx1ZXM9e3ZhbHVlfVxuICAgICAgICAgICAgICAgICAgICAgICAgdHlwZT17dHlwZX1cbiAgICAgICAgICAgICAgICAgICAgICAgIHRpbWU9e3RpbWVPYmogYXMgVGltZX1cbiAgICAgICAgICAgICAgICAgICAgICAgIG1hcmtUaW1lQXNTZXQ9e21hcmtUaW1lQXNTZXR9XG4gICAgICAgICAgICAgICAgICAgICAgICBoYXNEZWZhdWx0VGltZT17aGFzRGVmYXVsdFRpbWUgfHwgaXNUaW1lU2V0W2lucHV0XX1cbiAgICAgICAgICAgICAgICAgICAgICAgIGlucHV0TmFtZT17aW5wdXR9XG4gICAgICAgICAgICAgICAgICAgICAgICB2YWx1ZT17dmFsdWVbaW5wdXRdfVxuICAgICAgICAgICAgICAgICAgICAgICAgdGltZUZvcm1hdD17dGltZUZvcm1hdH1cbiAgICAgICAgICAgICAgICAgICAgICAgIHNlbGVjdD17c2VsZWN0fVxuICAgICAgICAgICAgICAgICAgICAgICAgbWF4PXttYXh9XG4gICAgICAgICAgICAgICAgICAgICAgICBtaW49e21pbn1cbiAgICAgICAgICAgICAgICAgICAgICAgIGxvY2FsZT17bG9jYWxlfVxuICAgICAgICAgICAgICAgICAgICAgICAgZGF0ZUZvcm1hdD17ZGF0ZUZvcm1hdH1cbiAgICAgICAgICAgICAgICAgICAgICAgIHQ9e3R9XG4gICAgICAgICAgICAgICAgICAgIC8+XG4gICAgICAgICAgICAgICAgKVxuICAgICAgICAgICAgfSl9XG4gICAgICAgIDwvZGl2PlxuICAgIClcbn1cblxuUG9wVXBDb21wb25lbnQucHJvdG90eXBlID0ge31cblxuZXhwb3J0IGNvbnN0IFBvcFVwID0gb25DbGlja091dHNpZGUoUG9wVXBDb21wb25lbnQpXG4iXX0=

package/lib/inputs/DatePicker/types.d.ts

@@ -0,0 +1,31 @@
+import { Moment } from 'moment';
+import { PopperProps } from 'react-popper';
+export declare const enum CalendarType {
+    BY_DAYS = "by_days",
+    BY_MONTHS = "by_months",
+    BY_YEARS = "by_years",
+    TIME_PICKER = "time_picker"
+}
+export declare const enum DateTimeControlName {
+    BEGIN = "begin",
+    DEFAULT_NAME = "singleDate",
+    END = "end"
+}
+export declare type DatePickerValue = Array<{
+    defaultTime?: string;
+    name: string | null;
+    value: string | null;
+}> | string | null;
+export declare type DateType = string | Moment | Date;
+export declare type Time = {
+    hours: number;
+    minutes: number;
+    seconds: number;
+};
+export declare type TimeExtended = Time & {
+    hasDefaultTime: boolean;
+};
+export declare type DefaultTime = Record<string, TimeExtended>;
+export declare type OnInputChangeHandler = (date: Moment | null, inputName: string, callback?: () => void) => void;
+export declare type PopperPositioningStrategy = PopperProps<unknown>['strategy'];
+export declare type PopperPlacement = PopperProps<unknown>['placement'];

package/lib/inputs/DatePicker/types.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateTimeControlName = exports.CalendarType = void 0;
+var CalendarType;
+exports.CalendarType = CalendarType;
+
+(function (CalendarType) {
+  CalendarType["BY_DAYS"] = "by_days";
+  CalendarType["BY_MONTHS"] = "by_months";
+  CalendarType["BY_YEARS"] = "by_years";
+  CalendarType["TIME_PICKER"] = "time_picker";
+})(CalendarType || (exports.CalendarType = CalendarType = {}));
+
+var DateTimeControlName;
+exports.DateTimeControlName = DateTimeControlName;
+
+(function (DateTimeControlName) {
+  DateTimeControlName["BEGIN"] = "begin";
+  DateTimeControlName["DEFAULT_NAME"] = "singleDate";
+  DateTimeControlName["END"] = "end";
+})(DateTimeControlName || (exports.DateTimeControlName = DateTimeControlName = {}));
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pbnB1dHMvRGF0ZVBpY2tlci90eXBlcy50cyJdLCJuYW1lcyI6WyJDYWxlbmRhclR5cGUiLCJEYXRlVGltZUNvbnRyb2xOYW1lIl0sIm1hcHBpbmdzIjoiOzs7Ozs7SUFHa0JBLFk7OztXQUFBQSxZO0FBQUFBLEVBQUFBLFk7QUFBQUEsRUFBQUEsWTtBQUFBQSxFQUFBQSxZO0FBQUFBLEVBQUFBLFk7R0FBQUEsWSw0QkFBQUEsWTs7SUFPQUMsbUI7OztXQUFBQSxtQjtBQUFBQSxFQUFBQSxtQjtBQUFBQSxFQUFBQSxtQjtBQUFBQSxFQUFBQSxtQjtHQUFBQSxtQixtQ0FBQUEsbUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBNb21lbnQgfSBmcm9tICdtb21lbnQnXG5pbXBvcnQgeyBQb3BwZXJQcm9wcyB9IGZyb20gJ3JlYWN0LXBvcHBlcidcblxuZXhwb3J0IGNvbnN0IGVudW0gQ2FsZW5kYXJUeXBlIHtcbiAgICBCWV9EQVlTID0gJ2J5X2RheXMnLFxuICAgIEJZX01PTlRIUyA9ICdieV9tb250aHMnLFxuICAgIEJZX1lFQVJTID0gJ2J5X3llYXJzJyxcbiAgICBUSU1FX1BJQ0tFUiA9ICd0aW1lX3BpY2tlcicsXG59XG5cbmV4cG9ydCBjb25zdCBlbnVtIERhdGVUaW1lQ29udHJvbE5hbWUge1xuICAgIEJFR0lOID0gJ2JlZ2luJyxcbiAgICBERUZBVUxUX05BTUUgPSAnc2luZ2xlRGF0ZScsXG4gICAgRU5EID0gJ2VuZCdcbn1cblxuZXhwb3J0IHR5cGUgRGF0ZVBpY2tlclZhbHVlID1cbiAgICBBcnJheTx7IGRlZmF1bHRUaW1lPzogc3RyaW5nLCBuYW1lOiBzdHJpbmcgfCBudWxsLCB2YWx1ZTogc3RyaW5nIHwgbnVsbCB9PlxuICAgIHwgc3RyaW5nXG4gICAgfCBudWxsXG5cbmV4cG9ydCB0eXBlIERhdGVUeXBlID0gc3RyaW5nIHwgTW9tZW50IHwgRGF0ZVxuXG5leHBvcnQgdHlwZSBUaW1lID0ge1xuICAgIGhvdXJzOiBudW1iZXIsXG4gICAgbWludXRlczogbnVtYmVyLFxuICAgIHNlY29uZHM6IG51bWJlclxufVxuXG5leHBvcnQgdHlwZSBUaW1lRXh0ZW5kZWQgPSBUaW1lICYge1xuICAgIGhhc0RlZmF1bHRUaW1lOiBib29sZWFuLFxufVxuXG5leHBvcnQgdHlwZSBEZWZhdWx0VGltZSA9IFJlY29yZDxzdHJpbmcsIFRpbWVFeHRlbmRlZD5cblxuZXhwb3J0IHR5cGUgT25JbnB1dENoYW5nZUhhbmRsZXIgPSAoZGF0ZTogTW9tZW50IHwgbnVsbCwgaW5wdXROYW1lOiBzdHJpbmcsIGNhbGxiYWNrPzogKCkgPT4gdm9pZCkgPT4gdm9pZFxuXG5leHBvcnQgdHlwZSBQb3BwZXJQb3NpdGlvbmluZ1N0cmF0ZWd5ID0gUG9wcGVyUHJvcHM8dW5rbm93bj5bJ3N0cmF0ZWd5J11cbmV4cG9ydCB0eXBlIFBvcHBlclBsYWNlbWVudCA9IFBvcHBlclByb3BzPHVua25vd24+WydwbGFjZW1lbnQnXVxuIl19

package/lib/inputs/DatePicker/utils.d.ts

@@ -0,0 +1,39 @@
+import moment, { LocaleSpecifier, Moment, MomentFormatSpecification } from 'moment/moment';
+import { DateType, DatePickerValue, DefaultTime } from './types';
+/**
+ * Дата (date) была после конца месяца другой даты(displayedMonth) или нет
+ */
+export declare const isDateFromNextMonth: (date: Moment, displayedMonth: Moment) => boolean;
+/**
+ * Дата (date) была до начала месяца другой даты(displayedMonth) или нет
+ */
+export declare const isDateFromPrevMonth: (date: Moment, displayedMonth: Moment) => boolean;
+/**
+ * Возвращает массив из недель(каждая неделя - массив из дней)
+ */
+export declare const weeks: (firstDay: Moment) => moment.Moment[][];
+/**
+ * добавить часы и минуты к дате
+ */
+export declare const addTime: (date: Moment, hours: number, minutes: number, secs: number) => moment.Moment;
+export declare const withLocale: (date: Moment, locale: LocaleSpecifier) => moment.Moment;
+/**
+ * преобразовать дату к moment-объекту
+ */
+export declare const parseDate: (value: DateType, dateFormat: MomentFormatSpecification) => moment.Moment;
+export declare const mapToValue: (val: DatePickerValue, defaultTime: DefaultTime, dateFormat: string, locale: string, defaultName: string) => Record<string, moment.Moment | null>;
+export declare const mapToDefaultTime: (val: DatePickerValue, defaultTime: string, defaultName: string, timeFormat?: string) => DefaultTime;
+export declare const buildDateFormat: (dateFormat?: string, timeFormat?: string, divider?: string) => string;
+export declare const replaceDictionary: (tmp: string | RegExp) => RegExp[];
+export declare const formatToMask: (format: string) => (string | RegExp)[];
+/**
+ * Функция проверки находится ли дата в промежутке max и min
+ */
+export declare const hasInsideMixMax: (date: string, { max, min }: Record<string, string>, dateFormat: MomentFormatSpecification) => boolean;
+export declare const getDeletedSymbol: (value: string, index: number) => string;
+export declare const replaceAt: (string: string, index: number, replacement: string) => string;
+export declare const objFromTime: (date: Moment) => {
+    minutes: number;
+    seconds: number;
+    hours: number;
+};

package/lib/inputs/DatePicker/utils.js

@@ -0,0 +1,304 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.objFromTime = exports.replaceAt = exports.getDeletedSymbol = exports.hasInsideMixMax = exports.formatToMask = exports.replaceDictionary = exports.buildDateFormat = exports.mapToDefaultTime = exports.mapToValue = exports.parseDate = exports.withLocale = exports.addTime = exports.weeks = exports.isDateFromPrevMonth = exports.isDateFromNextMonth = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _moment = _interopRequireDefault(require("moment/moment"));
+
+var _flattenDeep = _interopRequireDefault(require("lodash/flattenDeep"));
+
+var _map = _interopRequireDefault(require("lodash/map"));
+
+var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));
+
+var _isNull = _interopRequireDefault(require("lodash/isNull"));
+
+/**
+ * Дата (date) была после конца месяца другой даты(displayedMonth) или нет
+ */
+var isDateFromNextMonth = function isDateFromNextMonth(date, displayedMonth) {
+  return date.year() > displayedMonth.year() || date.year() === displayedMonth.year() && date.month() > displayedMonth.month();
+};
+/**
+ * Дата (date) была до начала месяца другой даты(displayedMonth) или нет
+ */
+
+
+exports.isDateFromNextMonth = isDateFromNextMonth;
+
+var isDateFromPrevMonth = function isDateFromPrevMonth(date, displayedMonth) {
+  return date.year() < displayedMonth.year() || date.year() === displayedMonth.year() && date.month() < displayedMonth.month();
+};
+/**
+ * Возвращает массив из недель(каждая неделя - массив из дней)
+ */
+
+
+exports.isDateFromPrevMonth = isDateFromPrevMonth;
+
+var weeks = function weeks(firstDay) {
+  var lastDay = firstDay.clone().add(35, 'days');
+  var day = firstDay.clone();
+  var weeks = [];
+
+  while (day <= lastDay) {
+    var week = [];
+
+    for (var i = 0; i < 7; i++) {
+      week.push(day.clone());
+
+      if (i === 6) {
+        weeks.push(week);
+      }
+
+      day.add(1, 'days');
+    }
+  }
+
+  return weeks;
+};
+/**
+ * добавить часы и минуты к дате
+ */
+
+
+exports.weeks = weeks;
+
+var addTime = function addTime(date, hours, minutes, secs) {
+  return date.clone().add(hours, 'h').add(minutes, 'm').add(secs, 's');
+};
+
+exports.addTime = addTime;
+
+var withLocale = function withLocale(date, locale) {
+  return date.clone().locale(locale);
+};
+/**
+ * преобразовать дату к moment-объекту
+ */
+
+
+exports.withLocale = withLocale;
+
+var parseDate = function parseDate(value, dateFormat) {
+  if (value instanceof Date) {
+    value = (0, _moment["default"])(value);
+  } else if (typeof value === 'string') {
+    value = (0, _moment["default"])(value, dateFormat);
+
+    if (!value.isValid()) {
+      // eslint-disable-next-line no-console
+      console.warn('Invalid date');
+    }
+  }
+
+  return value;
+};
+
+exports.parseDate = parseDate;
+
+var mapToValue = function mapToValue(val, defaultTime, dateFormat, locale, defaultName) {
+  var res = {};
+
+  if (Array.isArray(val)) {
+    (0, _map["default"])(val, function (_ref) {
+      var value = _ref.value,
+          name = _ref.name;
+
+      if (!name) {
+        name = '';
+      }
+
+      if (!value) {
+        res[name] = null;
+      } else {
+        res[name] = addTime(withLocale(parseDate(value, dateFormat), locale).startOf('day'), defaultTime[name].hours, defaultTime[name].minutes, defaultTime[name].seconds);
+      }
+    });
+    return res;
+  }
+
+  if (!val) {
+    return (0, _defineProperty2["default"])({}, defaultName, null);
+  }
+
+  res[defaultName] = addTime(withLocale(parseDate(val, dateFormat), locale).startOf('day'), defaultTime[defaultName].hours, defaultTime[defaultName].minutes, defaultTime[defaultName].seconds);
+  return res;
+};
+
+exports.mapToValue = mapToValue;
+
+var mapToDefaultTime = function mapToDefaultTime(val, defaultTime, defaultName) {
+  var timeFormat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'HH:mm:ss';
+
+  if (Array.isArray(val)) {
+    var _result = {};
+    (0, _map["default"])(val, function (_ref3) {
+      var name = _ref3.name,
+          defaultTime = _ref3.defaultTime,
+          value = _ref3.value;
+
+      if ((0, _isNull["default"])(name)) {
+        name = '';
+      }
+
+      _result[name] = {
+        hours: defaultTime ? (0, _moment["default"])(defaultTime || '00:00', timeFormat).hour() : value && (0, _moment["default"])(value).hour() || 0,
+        minutes: defaultTime ? (0, _moment["default"])(defaultTime || '00:00', timeFormat).minute() : value && (0, _moment["default"])(value).minute() || 0,
+        seconds: defaultTime ? (0, _moment["default"])(defaultTime || '00:00', timeFormat).second() : value && (0, _moment["default"])(value).second() || 0,
+        hasDefaultTime: false
+      };
+
+      if (_result[name].hours || _result[name].minutes || _result[name].seconds || timeFormat) {
+        _result[name].hasDefaultTime = true;
+      }
+    });
+    return _result;
+  }
+
+  if (val) {
+    return (0, _defineProperty2["default"])({}, defaultName, {
+      hours: (0, _moment["default"])(val).hour(),
+      minutes: (0, _moment["default"])(val).minute(),
+      seconds: (0, _moment["default"])(val).second(),
+      hasDefaultTime: true
+    });
+  }
+
+  var result = (0, _defineProperty2["default"])({}, defaultName, {
+    hours: (0, _moment["default"])(defaultTime, timeFormat).hour(),
+    minutes: (0, _moment["default"])(defaultTime, timeFormat).minute(),
+    seconds: (0, _moment["default"])(defaultTime, timeFormat).second(),
+    hasDefaultTime: false
+  });
+
+  if (result[defaultName].hours || result[defaultName].minutes || result[defaultName].seconds) {
+    result[defaultName].hasDefaultTime = true;
+  }
+
+  return result;
+};
+
+exports.mapToDefaultTime = mapToDefaultTime;
+
+var buildDateFormat = function buildDateFormat(dateFormat, timeFormat, divider) {
+  return "".concat(dateFormat || '').concat(dateFormat && timeFormat ? divider : '').concat(timeFormat || '');
+};
+
+exports.buildDateFormat = buildDateFormat;
+
+var replaceDictionary = function replaceDictionary(tmp) {
+  switch (tmp) {
+    case 'DD':
+      return [/[0-3]/, /\d/];
+
+    case 'MM':
+      return [/[01]/, /\d/];
+
+    case 'YY':
+      return [/\d/, /\d/];
+
+    case 'YYYY':
+      return [/[0-2]/, /\d/, /\d/, /\d/];
+
+    case 'H':
+    case 'HH':
+      return [/[0-2]/, /\d/];
+
+    case 'h':
+    case 'hh':
+      return [/[01]/, /\d/];
+
+    case 'k':
+    case 'kk':
+      return [/[12]/, /\d/];
+
+    case 's':
+    case 'm':
+    case 'ss':
+    case 'mm':
+      return [/[0-5]/, /\d/];
+
+    default:
+      return [/\d/];
+  }
+};
+
+exports.replaceDictionary = replaceDictionary;
+
+var formatToMask = function formatToMask(format) {
+  var splitedFormat = format.split(/\b/gi);
+  return (0, _flattenDeep["default"])((0, _map["default"])(splitedFormat, function (item) {
+    if (item.search(/([a-z])\1+/gi) !== -1) {
+      return replaceDictionary(item);
+    }
+
+    return item;
+  }));
+};
+/**
+ * Функция проверки находится ли дата в промежутке max и min
+ */
+
+
+exports.formatToMask = formatToMask;
+
+var hasInsideMixMax = function hasInsideMixMax(date, _ref5, dateFormat) {
+  var max = _ref5.max,
+      min = _ref5.min;
+  var currentDate = (0, _moment["default"])(date, dateFormat); // @ts-ignore @fixme не определяется библиотечный метод _f
+  // eslint-disable-next-line no-underscore-dangle
+
+  var hasFormat = function hasFormat(range) {
+    return !(0, _isUndefined["default"])((0, _moment["default"])(range)._f);
+  };
+
+  var lessOrEqual = function lessOrEqual(range, dateFormat) {
+    return hasFormat(range) ? (0, _moment["default"])(range) <= currentDate : (0, _moment["default"])(range, dateFormat) <= currentDate;
+  };
+
+  var moreOrEqual = function moreOrEqual(range, dateFormat) {
+    return hasFormat(range) ? (0, _moment["default"])(range) >= currentDate : (0, _moment["default"])(range, dateFormat) >= currentDate;
+  };
+
+  if (!max && !min) {
+    return true;
+  }
+
+  if (!max && min && lessOrEqual(min, dateFormat) || max && !min && moreOrEqual(max, dateFormat) || max && min && lessOrEqual(min, dateFormat) && moreOrEqual(max, dateFormat)) {
+    return true;
+  }
+
+  return false;
+};
+
+exports.hasInsideMixMax = hasInsideMixMax;
+
+var getDeletedSymbol = function getDeletedSymbol(value, index) {
+  return value.substring(index - 1, index);
+};
+
+exports.getDeletedSymbol = getDeletedSymbol;
+
+var replaceAt = function replaceAt(string, index, replacement) {
+  return string.substring(0, index - 1) + replacement + string.substring(index, string.length);
+};
+
+exports.replaceAt = replaceAt;
+
+var objFromTime = function objFromTime(date) {
+  return {
+    minutes: date.minutes(),
+    seconds: date.seconds(),
+    hours: date.hours()
+  };
+};
+
+exports.objFromTime = objFromTime;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/inputs/DatePicker/utils.ts"],"names":["isDateFromNextMonth","date","displayedMonth","year","month","isDateFromPrevMonth","weeks","firstDay","lastDay","clone","add","day","week","i","push","addTime","hours","minutes","secs","withLocale","locale","parseDate","value","dateFormat","Date","isValid","console","warn","mapToValue","val","defaultTime","defaultName","res","Array","isArray","name","startOf","seconds","mapToDefaultTime","timeFormat","result","hour","minute","second","hasDefaultTime","buildDateFormat","divider","replaceDictionary","tmp","formatToMask","format","splitedFormat","split","item","search","hasInsideMixMax","max","min","currentDate","hasFormat","range","_f","lessOrEqual","moreOrEqual","getDeletedSymbol","index","substring","replaceAt","string","replacement","length","objFromTime"],"mappings":"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","sourcesContent":["import moment, { LocaleSpecifier, Moment, MomentFormatSpecification, MomentInput } from 'moment/moment'\nimport flattenDeep from 'lodash/flattenDeep'\nimport map from 'lodash/map'\nimport isUndefined from 'lodash/isUndefined'\nimport isNull from 'lodash/isNull'\n\nimport { DateType, DatePickerValue, DefaultTime } from './types'\n\n/**\n * Дата (date) была после конца месяца другой даты(displayedMonth) или нет\n */\nexport const isDateFromNextMonth = (date: Moment, displayedMonth: Moment) => (\n    date.year() > displayedMonth.year() ||\n    (date.year() === displayedMonth.year() &&\n        date.month() > displayedMonth.month())\n)\n\n/**\n * Дата (date) была до начала месяца другой даты(displayedMonth) или нет\n */\nexport const isDateFromPrevMonth = (date: Moment, displayedMonth: Moment) => (\n    date.year() < displayedMonth.year() ||\n    (date.year() === displayedMonth.year() &&\n        date.month() < displayedMonth.month())\n)\n\n/**\n * Возвращает массив из недель(каждая неделя - массив из дней)\n */\nexport const weeks = (firstDay: Moment) => {\n    const lastDay = firstDay.clone().add(35, 'days')\n    const day = firstDay.clone()\n    const weeks = []\n\n    while (day <= lastDay) {\n        const week = []\n\n        for (let i = 0; i < 7; i++) {\n            week.push(day.clone())\n            if (i === 6) {\n                weeks.push(week)\n            }\n            day.add(1, 'days')\n        }\n    }\n\n    return weeks\n}\n\n/**\n * добавить часы и минуты к дате\n */\nexport const addTime = (date: Moment, hours: number, minutes: number, secs: number) => date\n    .clone()\n    .add(hours, 'h')\n    .add(minutes, 'm')\n    .add(secs, 's')\n\nexport const withLocale = (date: Moment, locale: LocaleSpecifier) => date.clone().locale(locale)\n\n/**\n * преобразовать дату к moment-объекту\n */\nexport const parseDate = (value: DateType, dateFormat: MomentFormatSpecification) => {\n    if (value instanceof Date) {\n        value = moment(value)\n    } else if (typeof value === 'string') {\n        value = moment(value, dateFormat)\n        if (!value.isValid()) {\n            // eslint-disable-next-line no-console\n            console.warn('Invalid date')\n        }\n    }\n\n    return value\n}\n\nexport const mapToValue = (\n    val: DatePickerValue,\n    defaultTime: DefaultTime,\n    dateFormat: string,\n    locale: string,\n    defaultName: string,\n) => {\n    const res: Record<string, Moment | null> = {}\n\n    if (Array.isArray(val)) {\n        map(val, ({ value, name }) => {\n            if (!name) {\n                name = ''\n            }\n            if (!value) {\n                res[name] = null\n            } else {\n                res[name] = addTime(\n                    withLocale(parseDate(value, dateFormat), locale).startOf('day'),\n                    defaultTime[name].hours,\n                    defaultTime[name].minutes,\n                    defaultTime[name].seconds,\n                )\n            }\n        })\n\n        return res\n    }\n\n    if (!val) {\n        return { [defaultName]: null }\n    }\n\n    res[defaultName] = addTime(\n        withLocale(parseDate(val, dateFormat), locale).startOf('day'),\n        defaultTime[defaultName].hours,\n        defaultTime[defaultName].minutes,\n        defaultTime[defaultName].seconds,\n    )\n\n    return res\n}\n\nexport const mapToDefaultTime = (\n    val: DatePickerValue,\n    defaultTime: string,\n    defaultName: string,\n    timeFormat = 'HH:mm:ss',\n) => {\n    if (Array.isArray(val)) {\n        const result: DefaultTime = {}\n\n        map(val, ({ name, defaultTime, value }) => {\n            if (isNull(name)) {\n                name = ''\n            }\n            result[name] = {\n                hours: defaultTime\n                    ? moment(defaultTime || '00:00', timeFormat).hour()\n                    : (value && moment(value).hour()) || 0,\n                minutes: defaultTime\n                    ? moment(defaultTime || '00:00', timeFormat).minute()\n                    : (value && moment(value).minute()) || 0,\n                seconds: defaultTime\n                    ? moment(defaultTime || '00:00', timeFormat).second()\n                    : (value && moment(value).second()) || 0,\n                hasDefaultTime: false,\n            }\n\n            if (\n                result[name].hours ||\n        result[name].minutes ||\n        result[name].seconds ||\n        timeFormat\n            ) {\n                result[name].hasDefaultTime = true\n            }\n        })\n\n        return result\n    }\n\n    if (val) {\n        return {\n            [defaultName]: {\n                hours: moment(val).hour(),\n                minutes: moment(val).minute(),\n                seconds: moment(val).second(),\n                hasDefaultTime: true,\n            },\n        }\n    }\n\n    const result = {\n        [defaultName]: {\n            hours: moment(defaultTime, timeFormat).hour(),\n            minutes: moment(defaultTime, timeFormat).minute(),\n            seconds: moment(defaultTime, timeFormat).second(),\n            hasDefaultTime: false,\n        },\n    }\n\n    if (\n        result[defaultName].hours ||\n    result[defaultName].minutes ||\n    result[defaultName].seconds\n    ) {\n        result[defaultName].hasDefaultTime = true\n    }\n\n    return result\n}\n\nexport const buildDateFormat = (dateFormat?: string, timeFormat?: string, divider?: string) => `${dateFormat || ''}${dateFormat && timeFormat ? divider : ''}${timeFormat || ''}`\n\nexport const replaceDictionary = (tmp: string | RegExp) => {\n    switch (tmp) {\n        case 'DD':\n            return [/[0-3]/, /\\d/]\n        case 'MM':\n            return [/[01]/, /\\d/]\n        case 'YY':\n            return [/\\d/, /\\d/]\n        case 'YYYY':\n            return [/[0-2]/, /\\d/, /\\d/, /\\d/]\n        case 'H':\n        case 'HH':\n            return [/[0-2]/, /\\d/]\n        case 'h':\n        case 'hh':\n            return [/[01]/, /\\d/]\n        case 'k':\n        case 'kk':\n            return [/[12]/, /\\d/]\n        case 's':\n        case 'm':\n        case 'ss':\n        case 'mm':\n            return [/[0-5]/, /\\d/]\n        default:\n            return [/\\d/]\n    }\n}\n\nexport const formatToMask = (format: string) => {\n    const splitedFormat = format.split(/\\b/gi)\n\n    return flattenDeep(\n        map(splitedFormat, (item: string): (RegExp | string) | Array<RegExp | string> => {\n            if (item.search(/([a-z])\\1+/gi) !== -1) {\n                return replaceDictionary(item)\n            }\n\n            return item\n        }),\n    )\n}\n\n/**\n * Функция проверки находится ли дата в промежутке max и min\n */\nexport const hasInsideMixMax = (\n    date: string,\n    { max, min }: Record<string, string>,\n    dateFormat: MomentFormatSpecification,\n) => {\n    const currentDate = moment(date, dateFormat)\n    // @ts-ignore @fixme не определяется библиотечный метод _f\n    // eslint-disable-next-line no-underscore-dangle\n    const hasFormat = (range: MomentInput) => !isUndefined(moment(range)._f)\n\n    const lessOrEqual = (range: MomentInput, dateFormat: MomentFormatSpecification) => (hasFormat(range)\n        ? moment(range) <= currentDate\n        : moment(range, dateFormat) <= currentDate)\n\n    const moreOrEqual = (range: MomentInput, dateFormat: MomentFormatSpecification) => (\n        hasFormat(range)\n            ? moment(range) >= currentDate\n            : moment(range, dateFormat) >= currentDate)\n\n    if (!max && !min) { return true }\n\n    if (\n        (!max && min && lessOrEqual(min, dateFormat)) ||\n    (max && !min && moreOrEqual(max, dateFormat)) ||\n    (max && min && lessOrEqual(min, dateFormat) && moreOrEqual(max, dateFormat))\n    ) {\n        return true\n    }\n\n    return false\n}\n\nexport const getDeletedSymbol = (value: string, index: number) => value.substring(index - 1, index)\n\nexport const replaceAt = (string: string, index: number, replacement: string) => (\n    string.substring(0, index - 1) +\n        replacement +\n        string.substring(index, string.length)\n)\n\nexport const objFromTime = (date: Moment) => ({\n    minutes: date.minutes(),\n    seconds: date.seconds(),\n    hours: date.hours(),\n})\n"]}

package/lib/inputs/Input.d.ts

@@ -0,0 +1,51 @@
+import React, { ChangeEvent, KeyboardEvent, LegacyRef } from 'react';
+import { TBaseInputProps, TBaseProps } from '../types';
+/**
+ * Контрол Input
+ * @reactProps {boolean} length - максимальная длина значения
+ * @reactProps {string} value - значение поля
+ * @reactProps {string} placeholder - плэйсхолдер
+ * @reactProps {boolean} disabled - флаг неактивности поля
+ * @reactProps {boolean} disabled - флаг только для чтения
+ * @reactProps {boolean} autoFocus - автофокус
+ * @reactProps {function} onFocus - callback на фокус
+ * @reactProps {function} onClick - callback на клик
+ * @reactProps {function} onPaste - callback при вставке в инпут
+ * @reactProps {function} onBlur - callback при блюре инпута
+ * @reactProps {function} onChange - callback при изменение инпута
+ * @reactProps {function} onKeyDown - callback при нажатии на кнопку клавиатуры
+ * @reactProps {boolean} autoFocus - флаг автофокуса
+ * @reactProps {string} className - css-класс
+ * @reactProps {object} style - объект стилей
+ * @reactProps {boolean} disabled - флаг неактивности поля
+ * @reactProps {string} type - тип поля
+ */
+declare type Props = TBaseProps & TBaseInputProps<any> & {
+    autoFocus: boolean;
+    checked: boolean;
+    inputRef?: LegacyRef<HTMLInputElement>;
+    label?: string;
+    length?: string;
+    max?: number;
+    min?: number;
+    name: string;
+    onClick(): void;
+    onKeyDown(arg: KeyboardEvent): void;
+    onPaste(): void;
+    placeholder?: string;
+    step?: string | number;
+    tabIndex: number;
+    type: string;
+};
+export declare class Input extends React.Component<Props> {
+    input: HTMLInputElement | null;
+    constructor(props: Props);
+    focus(): void;
+    blur(): void;
+    handleChange(e: ChangeEvent<HTMLInputElement>): void;
+    setRef(node: HTMLInputElement): void;
+    handleKeyDown: (evt: KeyboardEvent<HTMLInputElement>) => void;
+    render(): JSX.Element;
+    static defaultProps: Props;
+}
+export {};