@itcase/ui 1.0.53 → 1.0.54

package/dist/_commonjsHelpers-facfc6d6.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;

package/dist/components/Avatar.js

@@ -101,8 +101,8 @@ function Avatar(props) {
     fillHover: iconFillHover,
     fillSize: iconFillSize,
     iconFill: iconItemFill,
-    size: iconSize,
     shape: iconShape,
+    size: iconSize,
     stroke: iconStroke,
     SvgImage: icon
   }), after));

package/dist/components/Choice.js

@@ -76,24 +76,24 @@ const Choice = /*#__PURE__*/React__default.default.forwardRef((props, ref) => {
     ref: controlRef
   }, /*#__PURE__*/React__default.default.createElement("div", {
     className: "choice__wrapper"
-  }, options?.map((item, i) => /*#__PURE__*/React__default.default.createElement("div", {
-    className: clsx__default.default('choice__item', borderColorClass, borderWidthClass, borderTypeClass, fillHoverClass, item.value === active.value && fillActiveClass, item.value === active.value && 'choice__item_active'),
-    key: item.value,
-    ref: optionsRefs.get(item.value)
+  }, options?.map(item => /*#__PURE__*/React__default.default.createElement("div", {
+    className: clsx__default.default('choice__item', borderColorClass, borderWidthClass, borderTypeClass, fillHoverClass, item.id === active.id && fillActiveClass, item.id === active.id && 'choice__item_active'),
+    key: item.id,
+    ref: optionsRefs.get(item.id)
   }, /*#__PURE__*/React__default.default.createElement("input", {
-    checked: item.value === active.value,
+    checked: item.id === active.id,
     className: "choice__item-radio",
-    id: item.label,
+    id: item.id,
     name: name,
     type: "radio",
-    value: item.value,
+    value: item.id,
     onChange: () => setActiveSegment(item)
   }), /*#__PURE__*/React__default.default.createElement("label", {
     className: clsx__default.default('choice__item-label'),
-    htmlFor: item.label
+    htmlFor: item.id
   }, /*#__PURE__*/React__default.default.createElement(index.Text, {
-    textColor: item.value === active.value ? labelTextActiveColor : labelTextColor,
-    size: labelTextSize
+    size: labelTextSize,
+    textColor: item.id === active.id ? labelTextActiveColor : labelTextColor
   }, item.label))))));
 });
 Choice.displayName = 'Choice';

package/dist/components/DadataHintField.js

@@ -0,0 +1,1141 @@
+'use strict';
+
+var React = require('react');
+var PropTypes = require('prop-types');
+var clsx = require('clsx');
+var _commonjsHelpers = require('../_commonjsHelpers-facfc6d6.js');
+var crypto = require('crypto');
+var index = require('./Input.js');
+require('../hooks/useDeviceTargetClass.js');
+require('lodash/castArray');
+require('lodash/camelCase');
+require('../context/UIContext.js');
+require('../hooks/useMediaQueries.js');
+require('react-responsive');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+var PropTypes__default = /*#__PURE__*/_interopDefault(PropTypes);
+var clsx__default = /*#__PURE__*/_interopDefault(clsx);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
+
+//
+
+var shallowequal = function shallowEqual(objA, objB, compare, compareContext) {
+  var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
+
+  if (ret !== void 0) {
+    return !!ret;
+  }
+
+  if (objA === objB) {
+    return true;
+  }
+
+  if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
+    return false;
+  }
+
+  var keysA = Object.keys(objA);
+  var keysB = Object.keys(objB);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+
+  // Test for A's keys different from B.
+  for (var idx = 0; idx < keysA.length; idx++) {
+    var key = keysA[idx];
+
+    if (!bHasOwnProperty(key)) {
+      return false;
+    }
+
+    var valueA = objA[key];
+    var valueB = objB[key];
+
+    ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
+
+    if (ret === false || (ret === void 0 && valueA !== valueB)) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+var shallowEqual = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(shallowequal);
+
+/**
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing. The function also has a property 'clear' 
+ * that is a function which will clear the timer to prevent previously scheduled executions. 
+ *
+ * @source underscore.js
+ * @see http://unscriptable.com/2009/03/20/debouncing-javascript-methods/
+ * @param {Function} function to wrap
+ * @param {Number} timeout in ms (`100`)
+ * @param {Boolean} whether to execute at the beginning (`false`)
+ * @api public
+ */
+
+function debounce(func, wait, immediate){
+  var timeout, args, context, timestamp, result;
+  if (null == wait) wait = 100;
+
+  function later() {
+    var last = Date.now() - timestamp;
+
+    if (last < wait && last >= 0) {
+      timeout = setTimeout(later, wait - last);
+    } else {
+      timeout = null;
+      if (!immediate) {
+        result = func.apply(context, args);
+        context = args = null;
+      }
+    }
+  }
+  var debounced = function(){
+    context = this;
+    args = arguments;
+    timestamp = Date.now();
+    var callNow = immediate && !timeout;
+    if (!timeout) timeout = setTimeout(later, wait);
+    if (callNow) {
+      result = func.apply(context, args);
+      context = args = null;
+    }
+
+    return result;
+  };
+
+  debounced.clear = function() {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+    }
+  };
+  
+  debounced.flush = function() {
+    if (timeout) {
+      result = func.apply(context, args);
+      context = args = null;
+      
+      clearTimeout(timeout);
+      timeout = null;
+    }
+  };
+
+  return debounced;
+}
+// Adds compatibility for ES modules
+debounce.debounce = debounce;
+
+var debounce_1 = debounce;
+
+let urlAlphabet =
+  'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+
+const POOL_SIZE_MULTIPLIER = 128;
+let pool, poolOffset;
+let fillPool = bytes => {
+  if (!pool || pool.length < bytes) {
+    pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+    crypto__default.default.randomFillSync(pool);
+    poolOffset = 0;
+  } else if (poolOffset + bytes > pool.length) {
+    crypto__default.default.randomFillSync(pool);
+    poolOffset = 0;
+  }
+  poolOffset += bytes;
+};
+let nanoid = (size = 21) => {
+  fillPool((size -= 0));
+  let id = '';
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += urlAlphabet[pool[i] & 63];
+  }
+  return id
+};
+
+var xhr;
+var makeRequest = function (method, endpoint, data, cache, onReceiveData) {
+    if (xhr) {
+        xhr.abort();
+    }
+    var cacheKey;
+    if (cache) {
+        cacheKey = cache.serializeCacheKey({
+            headers: data.headers,
+            body: data.json,
+            url: endpoint,
+            method: method,
+        });
+        var cachedData = cache.get(cacheKey);
+        if (cachedData) {
+            onReceiveData(cachedData);
+            return;
+        }
+    }
+    xhr = new XMLHttpRequest();
+    xhr.open(method, endpoint);
+    if (data.headers) {
+        Object.entries(data.headers).forEach(function (_a) {
+            var header = _a[0], headerValue = _a[1];
+            xhr.setRequestHeader(header, headerValue);
+        });
+    }
+    xhr.send(JSON.stringify(data.json));
+    xhr.onreadystatechange = function () {
+        var _a;
+        if (!xhr || xhr.readyState !== 4) {
+            return;
+        }
+        if (xhr.status === 200) {
+            var payload = (_a = JSON.parse(xhr.response)) === null || _a === void 0 ? void 0 : _a.suggestions;
+            if (payload) {
+                cache === null || cache === void 0 ? void 0 : cache.set(cacheKey, payload);
+                onReceiveData(payload);
+            }
+        }
+    };
+};
+
+var HttpCache = /** @class */ (function () {
+    function HttpCache() {
+    }
+    /**
+     * Сгенерировать уникальный ключ кеша из параметров http-запроса
+     * @example
+     * ```ts
+     * cache.serializeCacheKey({
+     *   url: 'https://example.com',
+     *   body: { key: "value" },
+     *   method: "POST"
+     * })
+     * ```
+     */
+    HttpCache.prototype.serializeCacheKey = function (payload) {
+        try {
+            return JSON.stringify(payload);
+        }
+        catch (_e) {
+            // на случай попытки сериализации объекта с циклическими зависимостями внутри
+            return payload.url + String(Math.random());
+        }
+    };
+    return HttpCache;
+}());
+
+var __extends$7 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var minute = 60000;
+var DefaultHttpCache = /** @class */ (function (_super) {
+    __extends$7(DefaultHttpCache, _super);
+    function DefaultHttpCache() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._map = new Map();
+        _this._ttl = 10 * minute;
+        return _this;
+    }
+    Object.defineProperty(DefaultHttpCache, "shared", {
+        /**
+         * Синглтон
+         * @example
+         * ```ts
+         * cache.shared.get('key');
+         * ```
+         */
+        get: function () {
+            if (!DefaultHttpCache.sharedInstance) {
+                DefaultHttpCache.sharedInstance = new DefaultHttpCache();
+            }
+            return DefaultHttpCache.sharedInstance;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DefaultHttpCache.prototype, "ttl", {
+        /**
+         * Время жизни кеша в миллисекундах
+         * @example
+         * ```ts
+         * cache.ttl = 60000;
+         * cache.ttl = Infinity;
+         * cache.tll = 0;
+         *
+         * // негативные значения игнорируются
+         * cache.ttl = -1;
+         * cache.ttl = Number.NEGATIVE_INFINITY;
+         * ```
+         */
+        get: function () {
+            return this._ttl;
+        },
+        set: function (ttl) {
+            if (typeof ttl === 'number' && ttl >= 0) {
+                this._ttl = ttl;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DefaultHttpCache.prototype, "size", {
+        /**
+         * Количество элементов в кеше
+         */
+        get: function () {
+            return this._map.size;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DefaultHttpCache.prototype.get = function (key) {
+        var data = this._map.get(key);
+        if (!data)
+            return null;
+        if (data.expires <= Date.now()) {
+            this.delete(key);
+            return null;
+        }
+        return data.data;
+    };
+    DefaultHttpCache.prototype.set = function (key, data) {
+        this._map.set(key, {
+            data: data,
+            expires: Date.now() + this.ttl,
+        });
+        return this;
+    };
+    DefaultHttpCache.prototype.delete = function (key) {
+        this._map.delete(key);
+        return this;
+    };
+    DefaultHttpCache.prototype.reset = function () {
+        this._map.clear();
+        return this;
+    };
+    return DefaultHttpCache;
+}(HttpCache));
+
+var __extends$6 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var BaseSuggestions = /** @class */ (function (_super) {
+    __extends$6(BaseSuggestions, _super);
+    function BaseSuggestions(props) {
+        var _this = _super.call(this, props) || this;
+        /**
+         * URL для загрузки подсказок, переопределяется в конкретном компоненте
+         */
+        _this.loadSuggestionsUrl = '';
+        _this.dontPerformBlurHandler = false;
+        _this.getSuggestionsUrl = function () {
+            var url = _this.props.url;
+            return url || _this.loadSuggestionsUrl;
+        };
+        _this.setupDebounce = function (delay) {
+            if (typeof delay === 'number' && delay > 0) {
+                _this.fetchSuggestions = debounce_1.debounce(_this.performFetchSuggestions, delay);
+            }
+            else {
+                _this.fetchSuggestions = _this.performFetchSuggestions;
+            }
+        };
+        _this.fetchSuggestions = function () {
+            //
+        };
+        _this.handleInputFocus = function (event) {
+            _this.setState({ isFocused: true });
+            var suggestions = _this.state.suggestions;
+            if (suggestions.length === 0) {
+                _this.fetchSuggestions();
+            }
+            var inputProps = _this.props.inputProps;
+            if (inputProps && inputProps.onFocus) {
+                inputProps.onFocus(event);
+            }
+        };
+        _this.handleInputBlur = function (event) {
+            var _a = _this.state, suggestions = _a.suggestions, suggestionIndex = _a.suggestionIndex;
+            var _b = _this.props, selectOnBlur = _b.selectOnBlur, inputProps = _b.inputProps;
+            _this.setState({ isFocused: false });
+            if (suggestions.length === 0) {
+                _this.fetchSuggestions();
+            }
+            if (selectOnBlur && !_this.dontPerformBlurHandler) {
+                if (suggestions.length > 0) {
+                    var suggestionIndexToSelect = suggestionIndex >= 0 && suggestionIndex < suggestions.length ? suggestionIndex : 0;
+                    _this.selectSuggestion(suggestionIndexToSelect, true);
+                }
+            }
+            _this.dontPerformBlurHandler = false;
+            if (inputProps && inputProps.onBlur) {
+                inputProps.onBlur(event);
+            }
+        };
+        _this.handleInputChange = function (event) {
+            var value = event.target.value;
+            var inputProps = _this.props.inputProps;
+            if (_this.didMount) {
+                _this.setState({ query: value, inputQuery: value, displaySuggestions: !!value }, function () {
+                    _this.fetchSuggestions();
+                });
+            }
+            if (inputProps && inputProps.onChange) {
+                inputProps.onChange(event);
+            }
+        };
+        _this.handleInputKeyDown = function (event) {
+            _this.handleKeyboard(event);
+            var inputProps = _this.props.inputProps;
+            if (inputProps && inputProps.onKeyDown) {
+                inputProps.onKeyDown(event);
+            }
+        };
+        _this.handleInputKeyPress = function (event) {
+            _this.handleKeyboard(event);
+            var inputProps = _this.props.inputProps;
+            if (inputProps && inputProps.onKeyPress) {
+                inputProps.onKeyPress(event);
+            }
+        };
+        _this.handleKeyboard = function (event) {
+            var _a = _this.state, suggestions = _a.suggestions, suggestionIndex = _a.suggestionIndex, inputQuery = _a.inputQuery;
+            if (event.which === 40) {
+                // Arrow down
+                event.preventDefault();
+                if (suggestionIndex < suggestions.length - 1) {
+                    var newSuggestionIndex = suggestionIndex + 1;
+                    var newInputQuery = suggestions[newSuggestionIndex].value;
+                    if (_this.didMount) {
+                        _this.setState({ suggestionIndex: newSuggestionIndex, query: newInputQuery });
+                    }
+                }
+            }
+            else if (event.which === 38) {
+                // Arrow up
+                event.preventDefault();
+                if (suggestionIndex >= 0) {
+                    var newSuggestionIndex = suggestionIndex - 1;
+                    var newInputQuery = newSuggestionIndex === -1 ? inputQuery : suggestions[newSuggestionIndex].value;
+                    if (_this.didMount) {
+                        _this.setState({ suggestionIndex: newSuggestionIndex, query: newInputQuery });
+                    }
+                }
+            }
+            else if (event.which === 13) {
+                // Enter
+                event.preventDefault();
+                if (suggestionIndex >= 0) {
+                    _this.selectSuggestion(suggestionIndex);
+                }
+            }
+        };
+        _this.performFetchSuggestions = function () {
+            var _a = _this.props, minChars = _a.minChars, token = _a.token;
+            var query = _this.state.query;
+            // Проверяем на минимальное количество символов для отправки
+            if (typeof minChars === 'number' && minChars > 0 && query.length < minChars) {
+                _this.setState({ suggestions: [], suggestionIndex: -1 });
+                return;
+            }
+            makeRequest('POST', _this.getSuggestionsUrl(), {
+                headers: {
+                    Accept: 'application/json',
+                    Authorization: "Token ".concat(token),
+                    'Content-Type': 'application/json',
+                },
+                json: _this.getLoadSuggestionsData(),
+            }, _this.httpCache, function (suggestions) {
+                if (_this.didMount) {
+                    _this.setState({ suggestions: suggestions, suggestionIndex: -1 });
+                }
+            });
+        };
+        _this.onSuggestionClick = function (index, event) {
+            event.stopPropagation();
+            _this.selectSuggestion(index);
+        };
+        _this.selectSuggestion = function (index, isSilent) {
+            if (isSilent === void 0) { isSilent = false; }
+            var suggestions = _this.state.suggestions;
+            var _a = _this.props, selectOnBlur = _a.selectOnBlur, onChange = _a.onChange;
+            if (suggestions.length >= index - 1) {
+                var suggestion = suggestions[index];
+                if (selectOnBlur) {
+                    _this.dontPerformBlurHandler = true;
+                }
+                _this.setState({ query: suggestion.value, inputQuery: suggestion.value, displaySuggestions: false }, function () {
+                    if (!isSilent) {
+                        _this.fetchSuggestions();
+                        setTimeout(function () { return _this.setCursorToEnd(_this.textInput); });
+                    }
+                });
+                if (onChange) {
+                    onChange(suggestion);
+                }
+            }
+        };
+        _this.setCursorToEnd = function (element) {
+            if (element) {
+                var valueLength = element.value.length;
+                if (element.selectionStart || element.selectionStart === 0) {
+                    // eslint-disable-next-line no-param-reassign
+                    element.selectionStart = valueLength;
+                    // eslint-disable-next-line no-param-reassign
+                    element.selectionEnd = valueLength;
+                    element.focus();
+                }
+            }
+        };
+        _this.getHighlightWords = function () {
+            var inputQuery = _this.state.inputQuery;
+            var wordsToPass = ['г', 'респ', 'ул', 'р-н', 'село', 'деревня', 'поселок', 'пр-д', 'пл', 'к', 'кв', 'обл', 'д'];
+            var words = inputQuery.replace(',', '').split(' ');
+            words = words.filter(function (word) {
+                return wordsToPass.indexOf(word) < 0;
+            });
+            return words;
+        };
+        /**
+         * Функция, которая вернет уникальный key для списка React
+         * @param suggestion
+         */
+        _this.getSuggestionKey = function (suggestion) { return suggestion.value; };
+        _this.focus = function () {
+            if (_this.textInput) {
+                _this.textInput.focus();
+            }
+        };
+        _this.setInputValue = function (value) {
+            _this.setState({ query: value || '', inputQuery: value || '' });
+        };
+        _this.didMount = false;
+        var _a = _this.props, defaultQuery = _a.defaultQuery, value = _a.value, delay = _a.delay;
+        var valueQuery = value ? value.value : undefined;
+        _this.setupDebounce(delay);
+        _this.state = {
+            query: defaultQuery || valueQuery || '',
+            inputQuery: defaultQuery || valueQuery || '',
+            isFocused: false,
+            displaySuggestions: true,
+            suggestions: [],
+            suggestionIndex: -1,
+        };
+        return _this;
+    }
+    BaseSuggestions.prototype.componentDidMount = function () {
+        this.didMount = true;
+    };
+    BaseSuggestions.prototype.componentDidUpdate = function (prevProps) {
+        var _a = this.props, value = _a.value, delay = _a.delay;
+        var _b = this.state, query = _b.query, inputQuery = _b.inputQuery;
+        if (!shallowEqual(prevProps.value, value)) {
+            var newQuery = value ? value.value : '';
+            if (query !== newQuery || inputQuery !== newQuery) {
+                this.setState({ query: newQuery, inputQuery: newQuery });
+            }
+        }
+        if (delay !== prevProps.delay) {
+            this.setupDebounce(delay);
+        }
+    };
+    BaseSuggestions.prototype.componentWillUnmount = function () {
+        this.didMount = false;
+    };
+    Object.defineProperty(BaseSuggestions.prototype, "uid", {
+        get: function () {
+            if (this.props.uid) {
+                return this.props.uid;
+            }
+            if (!this._uid) {
+                this._uid = nanoid();
+            }
+            return this._uid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BaseSuggestions.prototype, "httpCache", {
+        get: function () {
+            var _a = this.props, cacheProp = _a.httpCache, ttl = _a.httpCacheTtl;
+            if (!cacheProp) {
+                return null;
+            }
+            if (cacheProp instanceof HttpCache) {
+                return cacheProp;
+            }
+            var cache = DefaultHttpCache.shared;
+            if (typeof ttl === 'number') {
+                cache.ttl = ttl;
+            }
+            return cache;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    BaseSuggestions.prototype.render = function () {
+        var _this = this;
+        var _a = this.props, inputProps = _a.inputProps, hintText = _a.hintText, containerClassName = _a.containerClassName, hintClassName = _a.hintClassName, suggestionsClassName = _a.suggestionsClassName, suggestionClassName = _a.suggestionClassName, currentSuggestionClassName = _a.currentSuggestionClassName, customInput = _a.customInput, children = _a.children;
+        var _b = this.state, query = _b.query, isFocused = _b.isFocused, suggestions = _b.suggestions, suggestionIndex = _b.suggestionIndex, displaySuggestions = _b.displaySuggestions;
+        var Component = typeof customInput !== 'undefined' ? customInput : 'input';
+        var optionsExpanded = isFocused && suggestions && displaySuggestions && suggestions.length > 0;
+        return (React__default.default.createElement("div", { role: "combobox", "aria-expanded": optionsExpanded ? 'true' : 'false', "aria-owns": this.uid, "aria-controls": this.uid, "aria-haspopup": "listbox", className: containerClassName || 'react-dadata react-dadata__container' },
+            React__default.default.createElement("div", null,
+                React__default.default.createElement(Component, __assign({ autoComplete: "off", className: "react-dadata__input" }, inputProps, { value: query, ref: function (input) {
+                        _this.textInput = input;
+                    }, onChange: this.handleInputChange, onKeyPress: this.handleInputKeyPress, onKeyDown: this.handleInputKeyDown, onFocus: this.handleInputFocus, onBlur: this.handleInputBlur }))),
+            optionsExpanded && (React__default.default.createElement("ul", { id: this.uid, "aria-expanded": true, role: "listbox", className: suggestionsClassName || 'react-dadata__suggestions' },
+                typeof hintText !== 'undefined' && (React__default.default.createElement("div", { className: hintClassName || 'react-dadata__suggestion-note' }, hintText)),
+                suggestions.map(function (suggestion, index) {
+                    var suggestionClass = suggestionClassName || 'react-dadata__suggestion';
+                    if (index === suggestionIndex) {
+                        suggestionClass += " ".concat(currentSuggestionClassName || 'react-dadata__suggestion--current');
+                    }
+                    return (React__default.default.createElement("button", { role: "option", "aria-selected": index === suggestionIndex ? 'true' : 'false', key: _this.getSuggestionKey(suggestion), onMouseDown: _this.onSuggestionClick.bind(_this, index), className: suggestionClass }, _this.renderOption(suggestion)));
+                }))),
+            children));
+    };
+    return BaseSuggestions;
+}(React__default.default.PureComponent));
+
+let IDX = 36;
+let HEX = "";
+while (IDX--) {
+  HEX += IDX.toString(36);
+}
+function uid(len = 11) {
+  let str = "";
+  let num = len;
+  while (num--) {
+    str += HEX[Math.random() * 36 | 0];
+  }
+  return str;
+}
+
+const escapeRegexp = (term) => term.replace(/[|\\{}()[\]^$+*?.-]/g, (char) => `\\${char}`);
+const termsToRegExpString = (terms) => terms.replace(/\s{2,}/g, " ").split(" ").join("|");
+const regexpQuery = ({
+  terms,
+  matchExactly = false
+}) => {
+  if (typeof terms !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  const escapedTerms = escapeRegexp(terms.trim());
+  return `(${matchExactly ? escapedTerms : termsToRegExpString(escapedTerms)})`;
+};
+const buildRegexp = ({
+  terms,
+  matchExactly = false
+}) => {
+  try {
+    const fromString = /^([/~@;%#'])(.*?)\1([gimsuy]*)$/.exec(terms);
+    if (fromString) {
+      return new RegExp(fromString[2], fromString[3]);
+    }
+    return new RegExp(regexpQuery({ terms, matchExactly }), "ig");
+  } catch (e) {
+    throw new TypeError("Expected terms to be either a string or a RegExp!");
+  }
+};
+
+const hasProp = (prop) => (obj) => obj !== null && typeof obj === "object" && prop in obj;
+const hasMatch = hasProp("match");
+const chunkExists = (chunk) => typeof chunk !== "undefined";
+function clip({
+  curr,
+  next,
+  prev,
+  clipBy = 3
+}) {
+  const words = curr.text.split(" ");
+  const len = words.length;
+  if (curr.match || clipBy >= len) {
+    return curr.text;
+  }
+  const ellipsis = "...";
+  if (chunkExists(next) && chunkExists(prev) && hasMatch(prev) && hasMatch(next)) {
+    if (len > clipBy * 2) {
+      return [
+        ...words.slice(0, clipBy),
+        ellipsis,
+        ...words.slice(-clipBy)
+      ].join(" ");
+    }
+    return curr.text;
+  }
+  if (chunkExists(next) && hasMatch(next)) {
+    return [ellipsis, ...words.slice(-clipBy)].join(" ");
+  }
+  if (chunkExists(prev) && hasMatch(prev)) {
+    return [...words.slice(0, clipBy), ellipsis].join(" ");
+  }
+  return curr.text;
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const hasLength = (str) => str.length > 0;
+const highlightWords = ({
+  text,
+  query,
+  clipBy,
+  matchExactly = false
+}) => {
+  const safeQuery = typeof query === "string" ? query.trim() : query;
+  if (safeQuery === "") {
+    return [
+      {
+        key: uid(),
+        text,
+        match: false
+      }
+    ];
+  }
+  const searchRegexp = buildRegexp({ terms: query, matchExactly });
+  return text.split(searchRegexp).filter(hasLength).map((str) => ({
+    // Compose the object for a match
+    key: uid(),
+    text: str,
+    match: matchExactly ? str.toLowerCase() === safeQuery.toLowerCase() : searchRegexp.test(str)
+  })).map((chunk, index, chunks) => __spreadValues(__spreadValues({}, chunk), typeof clipBy === "number" && {
+    // We only overwrite the text if there is a clip
+    text: clip(__spreadProps(__spreadValues(__spreadValues({
+      curr: chunk
+    }, index < chunks.length - 1 && { next: chunks[index + 1] }), index > 0 && { prev: chunks[index - 1] }), {
+      // If this wasn't the first chunk, set the previous chunk
+      clipBy
+    }))
+  }));
+};
+
+var __extends$5 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var HighlightWords = /** @class */ (function (_super) {
+    __extends$5(HighlightWords, _super);
+    function HighlightWords() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    HighlightWords.prototype.render = function () {
+        var _a = this.props, text = _a.text, words = _a.words, highlightClassName = _a.highlightClassName, _b = _a.tagName, tagName = _b === void 0 ? 'span' : _b;
+        var query = typeof words === 'string' ? words : words.join(' ');
+        var chunks = highlightWords({ text: text, query: query });
+        return (React__default.default.createElement("span", { "aria-label": text }, chunks.map(function (chunk) {
+            if (!chunk.match) {
+                return React__default.default.createElement("span", { key: chunk.key, "aria-hidden": true }, chunk.text);
+            }
+            var Component = tagName;
+            return (React__default.default.createElement(Component, { key: chunk.key, className: highlightClassName, "aria-hidden": true }, chunk.text));
+        })));
+    };
+    return HighlightWords;
+}(React.PureComponent));
+
+var __extends$4 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/** @class */ ((function (_super) {
+    __extends$4(AddressSuggestions, _super);
+    function AddressSuggestions() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.loadSuggestionsUrl = 'https://suggestions.dadata.ru/suggestions/api/4_1/rs/suggest/address';
+        _this.getLoadSuggestionsData = function () {
+            var _a = _this.props, count = _a.count, filterFromBound = _a.filterFromBound, filterToBound = _a.filterToBound, filterLocations = _a.filterLocations, filterLocationsBoost = _a.filterLocationsBoost, filterLanguage = _a.filterLanguage, filterRestrictValue = _a.filterRestrictValue;
+            var query = _this.state.query;
+            // TODO: Type this params
+            var requestPayload = {
+                query: query,
+                count: count || 10,
+            };
+            // Ограничение поиска по типу
+            if (filterFromBound && filterToBound) {
+                requestPayload.from_bound = { value: filterFromBound };
+                requestPayload.to_bound = { value: filterToBound };
+            }
+            // Язык подсказок
+            if (filterLanguage) {
+                requestPayload.language = filterLanguage;
+            }
+            // Сужение области поиска
+            if (filterLocations) {
+                requestPayload.locations = filterLocations;
+            }
+            // Приоритет города при ранжировании
+            if (filterLocationsBoost) {
+                requestPayload.locations_boost = filterLocationsBoost;
+            }
+            // @see https://confluence.hflabs.ru/pages/viewpage.action?pageId=1023737934
+            if (filterRestrictValue) {
+                requestPayload.restrict_value = true;
+            }
+            return requestPayload;
+        };
+        _this.renderOption = function (suggestion) {
+            var _a = _this.props, renderOption = _a.renderOption, highlightClassName = _a.highlightClassName;
+            var query = _this.state.query;
+            return renderOption ? (renderOption(suggestion, query)) : (React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), tagName: "mark", text: suggestion.value }));
+        };
+        return _this;
+    }
+    return AddressSuggestions;
+})(BaseSuggestions));
+
+var __extends$3 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var PartySuggestions = /** @class */ (function (_super) {
+    __extends$3(PartySuggestions, _super);
+    function PartySuggestions() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.loadSuggestionsUrl = 'https://suggestions.dadata.ru/suggestions/api/4_1/rs/suggest/party';
+        _this.getLoadSuggestionsData = function () {
+            var _a = _this.props, count = _a.count, filterStatus = _a.filterStatus, filterType = _a.filterType, filterOkved = _a.filterOkved, filterLocations = _a.filterLocations, filterLocationsBoost = _a.filterLocationsBoost;
+            var query = _this.state.query;
+            var requestPayload = {
+                query: query,
+                count: count || 10,
+            };
+            // Ограничение по статусу организации
+            if (filterStatus) {
+                requestPayload.status = filterStatus;
+            }
+            // Ограничение по ОКВЭД
+            // @see https://confluence.hflabs.ru/pages/viewpage.action?pageId=1093075333
+            if (filterOkved) {
+                requestPayload.okved = filterOkved;
+            }
+            // Ограничение по типу организации
+            if (filterType) {
+                requestPayload.type = filterType;
+            }
+            // Сужение области поиска
+            if (filterLocations) {
+                requestPayload.locations = filterLocations;
+            }
+            // Приоритет города при ранжировании
+            if (filterLocationsBoost) {
+                requestPayload.locations_boost = filterLocationsBoost;
+            }
+            return requestPayload;
+        };
+        _this.getSuggestionKey = function (suggestion) { return suggestion.data.hid; };
+        _this.renderOption = function (suggestion) {
+            var _a = _this.props, renderOption = _a.renderOption, highlightClassName = _a.highlightClassName;
+            var query = _this.state.query;
+            return renderOption ? (renderOption(suggestion, query)) : (React__default.default.createElement("div", null,
+                React__default.default.createElement("div", { className: suggestion.data.state.status === 'LIQUIDATED' ? 'react-dadata__suggestion--line-through' : undefined },
+                    React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), text: suggestion.value })),
+                React__default.default.createElement("div", { className: "react-dadata__suggestion-subtitle" },
+                    suggestion.data.inn && React__default.default.createElement("div", { className: "react-dadata__suggestion-subtitle-item" }, suggestion.data.inn),
+                    suggestion.data.address && suggestion.data.address.value && (React__default.default.createElement("div", { className: "react-dadata__suggestion-subtitle-item" },
+                        React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), text: suggestion.data.address.value }))))));
+        };
+        return _this;
+    }
+    return PartySuggestions;
+}(BaseSuggestions));
+
+var __extends$2 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/** @class */ ((function (_super) {
+    __extends$2(BankSuggestions, _super);
+    function BankSuggestions() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.loadSuggestionsUrl = 'https://suggestions.dadata.ru/suggestions/api/4_1/rs/suggest/bank';
+        _this.getLoadSuggestionsData = function () {
+            var _a = _this.props, count = _a.count, filterStatus = _a.filterStatus, filterType = _a.filterType, filterLocations = _a.filterLocations, filterLocationsBoost = _a.filterLocationsBoost;
+            var query = _this.state.query;
+            var requestPayload = {
+                query: query,
+                count: count || 10,
+            };
+            // Ограничение по статусу организации
+            if (filterStatus) {
+                requestPayload.status = filterStatus;
+            }
+            // Ограничение по типу организации
+            if (filterType) {
+                requestPayload.type = filterType;
+            }
+            // Сужение области поиска
+            if (filterLocations) {
+                requestPayload.locations = filterLocations;
+            }
+            // Приоритет города при ранжировании
+            if (filterLocationsBoost) {
+                requestPayload.locations_boost = filterLocationsBoost;
+            }
+            return requestPayload;
+        };
+        _this.getSuggestionKey = function (suggestion) { return "".concat(suggestion.data.bic); };
+        _this.renderOption = function (suggestion) {
+            var _a = _this.props, renderOption = _a.renderOption, highlightClassName = _a.highlightClassName;
+            var query = _this.state.query;
+            return renderOption ? (renderOption(suggestion, query)) : (React__default.default.createElement("div", null,
+                React__default.default.createElement("div", { className: suggestion.data.state.status === 'LIQUIDATED' ? 'react-dadata__suggestion--line-through' : undefined },
+                    React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), text: suggestion.value })),
+                React__default.default.createElement("div", { className: "react-dadata__suggestion-subtitle" },
+                    suggestion.data.bic && React__default.default.createElement("div", { className: "react-dadata__suggestion-subtitle-item" }, suggestion.data.bic),
+                    suggestion.data.address && suggestion.data.address.value && (React__default.default.createElement("div", { className: "react-dadata__suggestion-subtitle-item" },
+                        React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), text: suggestion.data.address.value }))))));
+        };
+        return _this;
+    }
+    return BankSuggestions;
+})(BaseSuggestions));
+
+var __extends$1 = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/** @class */ ((function (_super) {
+    __extends$1(FioSuggestions, _super);
+    function FioSuggestions() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.loadSuggestionsUrl = 'https://suggestions.dadata.ru/suggestions/api/4_1/rs/suggest/fio';
+        _this.getLoadSuggestionsData = function () {
+            var _a = _this.props, count = _a.count, filterGender = _a.filterGender, filterParts = _a.filterParts;
+            var query = _this.state.query;
+            var requestPayload = {
+                query: query,
+                count: count || 10,
+            };
+            // Ограничение по полу
+            if (filterGender) {
+                requestPayload.gender = filterGender;
+            }
+            // Ограничение по части ФИО
+            if (filterParts) {
+                requestPayload.parts = filterParts;
+            }
+            return requestPayload;
+        };
+        _this.getSuggestionKey = function (suggestion) {
+            return "name:".concat(suggestion.data.name || '', "surname:").concat(suggestion.data.surname || '', "patronymic:").concat(suggestion.data.patronymic || '');
+        };
+        _this.renderOption = function (suggestion) {
+            var _a = _this.props, renderOption = _a.renderOption, highlightClassName = _a.highlightClassName;
+            var query = _this.state.query;
+            return renderOption ? (renderOption(suggestion, query)) : (React__default.default.createElement("div", null,
+                React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), text: suggestion.value })));
+        };
+        return _this;
+    }
+    return FioSuggestions;
+})(BaseSuggestions));
+
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+/** @class */ ((function (_super) {
+    __extends(EmailSuggestions, _super);
+    function EmailSuggestions() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.loadSuggestionsUrl = 'https://suggestions.dadata.ru/suggestions/api/4_1/rs/suggest/email';
+        _this.getLoadSuggestionsData = function () {
+            var count = _this.props.count;
+            var query = _this.state.query;
+            return {
+                query: query,
+                count: count || 10,
+            };
+        };
+        _this.getSuggestionKey = function (suggestion) { return suggestion.value; };
+        _this.renderOption = function (suggestion) {
+            var _a = _this.props, renderOption = _a.renderOption, highlightClassName = _a.highlightClassName;
+            var query = _this.state.query;
+            return renderOption ? (renderOption(suggestion, query)) : (React__default.default.createElement("div", null,
+                React__default.default.createElement(HighlightWords, { highlightClassName: highlightClassName || 'react-dadata--highlighted', words: _this.getHighlightWords(), text: suggestion.value })));
+        };
+        return _this;
+    }
+    return EmailSuggestions;
+})(BaseSuggestions));
+
+function DadataHintField(props) {
+  const {
+    delay,
+    inputProps,
+    setValue,
+    input,
+    meta,
+    token
+  } = props;
+  const dadataInputProps = React.useMemo(() => {
+    return {
+      ...inputProps,
+      className: clsx__default.default('react-dadata__input', meta.active && 'input_state_focus', meta.error && meta.touched && 'input_state_error'),
+      // https://www.npmjs.com/package/react-dadata
+      // "Свойство value игнорируется."
+      // value: input.value,
+      inputValue: input.value,
+      onFocus: input.onFocus,
+      onBlur: input.onBlur,
+      onChange: input.onChange
+    };
+  }, [inputProps, meta.active, meta.error, meta.touched, input.value, input.onFocus, input.onBlur, input.onChange]);
+  return /*#__PURE__*/React__default.default.createElement(PartySuggestions, {
+    customInput: DadataСustomInput,
+    delay: delay || 750,
+    inputProps: dadataInputProps,
+    minChars: 3,
+    token: token,
+    onChange: setValue
+  });
+}
+DadataHintField.propTypes = {
+  delay: PropTypes__default.default.number,
+  input: PropTypes__default.default.object,
+  inputProps: PropTypes__default.default.object,
+  meta: PropTypes__default.default.object,
+  setValue: PropTypes__default.default.func,
+  token: PropTypes__default.default.string
+};
+function DadataСustomInput(props) {
+  const {
+    inputValue,
+    ...otherProps
+  } = props;
+  return /*#__PURE__*/React__default.default.createElement(index.Input, Object.assign({}, otherProps, {
+    value: inputValue
+  }));
+}
+DadataСustomInput.propTypes = {
+  inputValue: PropTypes__default.default.object
+};
+
+exports.DadataHintField = DadataHintField;

package/dist/components/DatePicker.js

@@ -3,6 +3,7 @@
 var React = require('react');
 var PropTypes = require('prop-types');
 var clsx = require('clsx');
+var _commonjsHelpers = require('../_commonjsHelpers-facfc6d6.js');
 var defineProperty = require('../defineProperty-f9e5e1f3.js');
 var ReactDOM = require('react-dom');
 var index = require('./Input.js');
@@ -64,10 +65,6 @@ var PropTypes__default = /*#__PURE__*/_interopDefault(PropTypes);
 var clsx__default = /*#__PURE__*/_interopDefault(clsx);
 var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 var classnames = {exports: {}};
 
 /*!
@@ -128,7 +125,7 @@ var classnames = {exports: {}};
 } (classnames));
 
 var classnamesExports = classnames.exports;
-var r = /*@__PURE__*/getDefaultExportFromCjs(classnamesExports);
+var r = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(classnamesExports);
 
 function requiredArgs(required, args) {
   if (args.length < required) {
@@ -9175,7 +9172,7 @@ var reactFastCompare = function isEqual(a, b) {
   }
 };
 
-var isEqual = /*@__PURE__*/getDefaultExportFromCjs(reactFastCompare);
+var isEqual = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(reactFastCompare);
 
 var EMPTY_MODIFIERS$1 = [];
 var usePopper = function usePopper(referenceElement, popperElement, options) {
@@ -9408,7 +9405,7 @@ if (__DEV__) {
 
 var warning_1 = warning;
 
-var warning$1 = /*@__PURE__*/getDefaultExportFromCjs(warning_1);
+var warning$1 = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(warning_1);
 
 function Reference(_ref) {
   var children = _ref.children,
@@ -10113,7 +10110,7 @@ function DatePickerInput(props) {
   //   datePickerProps.isStartDefaultNull ? null : new Date(),
   // )
 
-  const startDate = React.useMemo(() => {
+  const start = React.useMemo(() => {
     if (value) {
       if (typeof value === 'string') {
         return new Date(value);
@@ -10125,6 +10122,7 @@ function DatePickerInput(props) {
     }
     return new Date();
   }, [value, datePickerProps.isStartDefaultNull]);
+  const [startDate, setStartDate] = React.useState(start);
   const [endDate, setEndDate] = React.useState(null);
 
   // const onChangeDate = useCallback(
@@ -10136,8 +10134,8 @@ function DatePickerInput(props) {
   // )
 
   const handleChange = ([newStartDate, newEndDate]) => {
-    onChange && onChange(newStartDate);
-    // setStartDate(newStartDate)
+    onChange && onChange(newStartDate, newEndDate);
+    setStartDate(newStartDate);
     setEndDate(newEndDate);
   };
   const renderDayContents = (day, date) => {

package/dist/components/Image.js

@@ -101,10 +101,10 @@ function Image(props) {
     className: clsx__default.default('image__wrapper', imageWrapperClassName),
     style: wrapperStyles
   }, /*#__PURE__*/React__default.default.createElement("img", {
-    src: src,
     alt: alt,
-    title: title,
+    src: src,
     style: imageStyles,
+    title: title,
     className: clsx__default.default('image__item', imageWidthClass, imageHeightClass, imageClassName, borderClass, borderColorImageClass),
     onError: onError
   }), overlay, caption, children), after);

package/dist/css/components/DadataHintField/DadataHintField.css

@@ -0,0 +1,43 @@
+.react-dadata__container{position:relative}.react-dadata__input{border:1px solid #ccc;border-radius:4px;box-sizing:border-box;display:block;font-size:16px;height:38px;outline:none;padding:0 10px;width:100%}.react-dadata__input:focus{border-color:#007cd6;box-shadow:inset 0 1px 1px rgba(0,0,0,.075),0 0 0 3px rgba(0,124,214,.3)}.react-dadata__suggestions{background-color:#fff;border-radius:4px;box-shadow:0 1px 6px 3px rgba(0,0,0,.1);left:0;list-style:none;margin:0;overflow:hidden;padding:0;position:absolute;right:0;text-align:left;top:calc(100% + 8px);z-index:10}.react-dadata__suggestion-note{color:#828282;font-size:14px;padding:10px 10px 5px}.react-dadata__suggestion{background:none;border:none;box-sizing:border-box;cursor:pointer;display:block;font-size:15px;padding:7px 10px;text-align:left;width:100%}.react-dadata__suggestion--line-through{text-decoration:line-through}.react-dadata__suggestion-subtitle{color:#777;font-size:14px;margin-top:4px}.react-dadata__suggestion-subtitle-item{display:inline-block;margin-bottom:4px;margin-right:16px}.react-dadata__suggestion-subtitle-item:last-child{margin-right:0}.react-dadata__suggestion--current{background-color:rgba(0,124,214,.15)}.react-dadata__suggestion:hover{background-color:rgba(0,124,214,.1)}.react-dadata mark{background:none}.react-dadata--highlighted{color:#0094ff}.react-dadata {
+  &__container {
+    width: 100%;
+    ^&__input {
+      color: var(--react-dadata-color);
+      padding: var(--react-dadata-padding);
+      border: 1px solid var(--react-dadata-border);
+      border-radius: var(--react-dadata-border-radius);
+      box-shadow: none;
+      &:hover {
+        border: solid 1px var(--react-dadata-hover-border);
+      }
+    }
+  }
+  &__suggestion {
+    position: relative !important;
+    &:hover {
+      background: var(--color-accent-tertiary);
+    }
+  }
+  &--highlighted {
+    color: var(--color-accent-primary);
+  }
+  & .input_state {
+    &_error {
+      border: solid 1px var(--react-dadata-error-border);
+      &:hover {
+        border: solid 1px var(--react-dadata-error-border);
+      }
+    }
+    &_focus {
+      border: solid 1px var(--react-dadata-focus-border);
+    }
+  }
+}:root {
+  --react-dadata-padding: 8px 12px;
+  --react-dadata-border-radius: 6px;
+  --react-dadata-color: var(--color-surface-text-primary);
+  --react-dadata-border: var(--color-surface-border-tertiary);
+  --react-dadata-hover-border: var(--color-surface-border-quaternary);
+  --react-dadata-focus-border: var(--color-surface-border-quaternary);
+  --react-dadata-error-border: var(--color-error-border-primary);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itcase/ui",
-  "version": "1.0.53",
+  "version": "1.0.54",
   "description": "UI components (Modal, Loader, Popup, etc)",
   "keywords": [
     "Modal",
@@ -49,6 +49,7 @@
     "prop-types": "^15.8.1",
     "rc-slider": "^10.2.1",
     "react": "^18.2.0",
+    "react-dadata": "^2.23.1",
     "react-date-range": "^1.4.0",
     "react-dom": "^18.2.0",
     "react-inlinesvg": "^4.0.3",