@salutejs/plasma-new-hope 0.88.0-canary.1225.9450426570.0 → 0.88.0-canary.1233.9437372350.0

package/styled-components/cjs/components/Select/hooks/useKeyboardNavigation.js

@@ -0,0 +1,307 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useKeyNavigation = exports.keys = void 0;
+var JUMP_SIZE = 10;
+var keys = exports.keys = {
+  Enter: 'Enter',
+  Space: 'Space',
+  Tab: 'Tab',
+  Escape: 'Escape',
+  Backspace: 'Backspace',
+  ArrowLeft: 'ArrowLeft',
+  ArrowRight: 'ArrowRight',
+  ArrowUp: 'ArrowUp',
+  ArrowDown: 'ArrowDown',
+  Home: 'Home',
+  End: 'End',
+  PageUp: 'PageUp',
+  PageDown: 'PageDown'
+};
+var getFurtherPath = function getFurtherPath(focusedPath, focusedToValueMap) {
+  var focusedPathAsString = focusedPath.reduce(function (acc, n) {
+    return "".concat(acc, "/").concat(n);
+  }, '').replace(/^(\/)/, '');
+  return focusedToValueMap.get(focusedPathAsString);
+};
+var useKeyNavigation = exports.useKeyNavigation = function useKeyNavigation(_ref) {
+  var focusedPath = _ref.focusedPath,
+    dispatchFocusedPath = _ref.dispatchFocusedPath,
+    path = _ref.path,
+    dispatchPath = _ref.dispatchPath,
+    pathMap = _ref.pathMap,
+    focusedToValueMap = _ref.focusedToValueMap,
+    handleToggle = _ref.handleToggle,
+    handlePressDown = _ref.handlePressDown,
+    focusedChipIndex = _ref.focusedChipIndex,
+    dispatchFocusedChipIndex = _ref.dispatchFocusedChipIndex,
+    value = _ref.value,
+    valueToItemMap = _ref.valueToItemMap,
+    multiselect = _ref.multiselect,
+    isTargetAmount = _ref.isTargetAmount;
+  var currentLength = pathMap.get(path === null || path === void 0 ? void 0 : path[path.length - 1]) || 0;
+  var currentIndex = (focusedPath === null || focusedPath === void 0 ? void 0 : focusedPath[focusedPath.length - 1]) || 0;
+  var onKeyDown = function onKeyDown(event) {
+    switch (event.code) {
+      case keys.ArrowUp:
+        {
+          if (focusedPath.length) {
+            if (currentIndex > 0) {
+              dispatchFocusedPath({
+                type: 'change_last_focus',
+                value: currentIndex - 1
+              });
+            }
+          } else {
+            dispatchPath({
+              type: 'opened_first_level'
+            });
+            dispatchFocusedPath({
+              type: 'set_initial_focus'
+            });
+            handleToggle(true);
+          }
+          if (Array.isArray(value)) {
+            dispatchFocusedChipIndex({
+              type: 'reset'
+            });
+          }
+          break;
+        }
+      case keys.ArrowDown:
+        {
+          if (focusedPath.length) {
+            if (currentIndex + 1 < currentLength) {
+              dispatchFocusedPath({
+                type: 'change_last_focus',
+                value: currentIndex + 1
+              });
+            }
+          } else {
+            dispatchPath({
+              type: 'opened_first_level'
+            });
+            dispatchFocusedPath({
+              type: 'set_initial_focus'
+            });
+            handleToggle(true);
+          }
+          if (Array.isArray(value)) {
+            dispatchFocusedChipIndex({
+              type: 'reset'
+            });
+          }
+          break;
+        }
+      case keys.ArrowLeft:
+        {
+          if (path[0]) {
+            if (focusedPath.length) {
+              dispatchPath({
+                type: 'removed_last_level'
+              });
+              dispatchFocusedPath({
+                type: 'return_prev_focus'
+              });
+            }
+            if (focusedPath.length === 1) {
+              handleToggle(false);
+            }
+          } else if (Array.isArray(value) && !isTargetAmount) {
+            dispatchFocusedChipIndex({
+              type: 'moveLeft'
+            });
+          }
+          break;
+        }
+      case keys.ArrowRight:
+        {
+          if (path[0]) {
+            if (!focusedPath.length) {
+              break;
+            }
+            var currentItem = getFurtherPath(focusedPath, focusedToValueMap);
+            if (currentItem !== null && currentItem !== void 0 && currentItem.items) {
+              dispatchPath({
+                type: 'added_next_level',
+                value: currentItem.value.toString()
+              });
+              dispatchFocusedPath({
+                type: 'add_focus',
+                value: 0
+              });
+            }
+          } else if (Array.isArray(value) && !isTargetAmount) {
+            dispatchFocusedChipIndex({
+              type: 'moveRight',
+              total: value.length
+            });
+          }
+          break;
+        }
+      case keys.Backspace:
+        {
+          if (!multiselect) break;
+          if (focusedChipIndex !== null) {
+            var _currentItem = valueToItemMap.get(value[focusedChipIndex]);
+            handlePressDown(_currentItem);
+            if (value.length === 1) {
+              dispatchFocusedChipIndex({
+                type: 'reset'
+              });
+              break;
+            }
+            if (focusedChipIndex === value.length - 1) {
+              dispatchFocusedChipIndex({
+                type: 'moveLeft'
+              });
+              break;
+            }
+          }
+          break;
+        }
+      case keys.Space:
+        {
+          event.preventDefault();
+          var _currentItem2 = getFurtherPath(focusedPath, focusedToValueMap);
+          if (!_currentItem2 || _currentItem2 !== null && _currentItem2 !== void 0 && _currentItem2.isDisabled || _currentItem2 !== null && _currentItem2 !== void 0 && _currentItem2.disabled) {
+            break;
+          }
+          handlePressDown(_currentItem2);
+          break;
+        }
+      case keys.Enter:
+        {
+          event.preventDefault();
+          if (Array.isArray(value)) {
+            dispatchFocusedChipIndex({
+              type: 'reset'
+            });
+          }
+          var _currentItem3 = getFurtherPath(focusedPath, focusedToValueMap);
+          if (_currentItem3 !== null && _currentItem3 !== void 0 && _currentItem3.isDisabled || _currentItem3 !== null && _currentItem3 !== void 0 && _currentItem3.disabled) {
+            break;
+          }
+          if (!path[0]) {
+            dispatchPath({
+              type: 'opened_first_level'
+            });
+            dispatchFocusedPath({
+              type: 'set_initial_focus'
+            });
+            break;
+          }
+          if (_currentItem3 !== null && _currentItem3 !== void 0 && _currentItem3.items) {
+            dispatchPath({
+              type: 'added_next_level',
+              value: _currentItem3.value.toString()
+            });
+            dispatchFocusedPath({
+              type: 'add_focus',
+              value: 0
+            });
+            break;
+          }
+          handlePressDown(_currentItem3);
+          break;
+        }
+      case keys.Tab:
+      case keys.Escape:
+        {
+          dispatchFocusedPath({
+            type: 'reset'
+          });
+          dispatchPath({
+            type: 'reset'
+          });
+          dispatchFocusedChipIndex({
+            type: 'reset'
+          });
+          handleToggle(false);
+          break;
+        }
+      case keys.Home:
+        {
+          if (path[0]) {
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: 0
+            });
+          } else {
+            dispatchPath({
+              type: 'opened_first_level'
+            });
+            dispatchFocusedPath({
+              type: 'set_initial_focus'
+            });
+            handleToggle(true);
+          }
+          break;
+        }
+      case keys.End:
+        {
+          if (path[0]) {
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: currentLength - 1
+            });
+          } else {
+            dispatchPath({
+              type: 'opened_first_level'
+            });
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: (pathMap.get('root') || 0) - 1
+            });
+            handleToggle(true);
+          }
+          break;
+        }
+      case keys.PageUp:
+        {
+          if (!path[0]) {
+            break;
+          }
+          if (currentIndex <= JUMP_SIZE) {
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: 0
+            });
+          } else {
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: currentIndex - JUMP_SIZE
+            });
+          }
+          break;
+        }
+      case keys.PageDown:
+        {
+          if (!path[0]) {
+            break;
+          }
+          if (currentLength - currentIndex <= JUMP_SIZE) {
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: currentLength - 1
+            });
+          } else {
+            dispatchFocusedPath({
+              type: 'change_last_focus',
+              value: currentIndex + JUMP_SIZE
+            });
+          }
+          break;
+        }
+      default:
+        {
+          break;
+        }
+    }
+  };
+  return {
+    onKeyDown: onKeyDown
+  };
+};

package/styled-components/cjs/components/Select/hooks/usePathMaps.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePathMaps = void 0;
+var _utils = /*#__PURE__*/require("../../../utils");
+// Рекурсивно проходим по дереву items и создаем 4 мапы: открытых путей, фокусов, выбранных элементов и айтемов.
+var usePathMaps = exports.usePathMaps = function usePathMaps(items) {
+  var pathMap = new Map();
+  var focusedToValueMap = new Map();
+  var valueToCheckedMap = new Map();
+  var valueToItemMap = new Map();
+  pathMap.set('root', items.length);
+  var rec = function rec(items) {
+    var prevIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+    items.forEach(function (item, index) {
+      var value = item.value,
+        innerItems = item.items;
+      var currIndex = "".concat(prevIndex, "/").concat(index).replace(/^(\/)/, '');
+      focusedToValueMap.set(currIndex, item);
+      valueToCheckedMap.set(value, false);
+      if ((0, _utils.isEmpty)(innerItems) || !innerItems) {
+        valueToItemMap.set(value, item);
+      } else {
+        pathMap.set(value, innerItems.length);
+        rec(innerItems, currIndex);
+      }
+    });
+  };
+  rec(items);
+  return [pathMap, focusedToValueMap, valueToCheckedMap, valueToItemMap];
+};

package/styled-components/cjs/components/Select/index.js

@@ -3,16 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _exportNames = {
-  selectRoot: true,
-  selectConfig: true,
-  selectClasses: true,
-  selectTokens: true
-};
-Object.defineProperty(exports, "selectClasses", {
+Object.defineProperty(exports, "SelectNotFoundContent", {
   enumerable: true,
   get: function get() {
-    return _Select2.classes;
+    return _SelectNotFoundContent.SelectNotFoundContent;
   }
 });
 Object.defineProperty(exports, "selectConfig", {
@@ -35,15 +29,4 @@ Object.defineProperty(exports, "selectTokens", {
 });
 var _Select = /*#__PURE__*/require("./Select");
 var _Select2 = /*#__PURE__*/require("./Select.tokens");
-var _ui = /*#__PURE__*/require("./ui");
-Object.keys(_ui).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  if (key in exports && exports[key] === _ui[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _ui[key];
-    }
-  });
-});
+var _SelectNotFoundContent = /*#__PURE__*/require("./elements/SelectNotFoundContent/SelectNotFoundContent");

package/styled-components/cjs/components/Select/reducers/focusedChipIndexReducer.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusedChipIndexReducer = focusedChipIndexReducer;
+function focusedChipIndexReducer(state, action) {
+  switch (action.type) {
+    case 'reset':
+      {
+        return null;
+      }
+    case 'moveLeft':
+      {
+        if (state === null) {
+          return 0;
+        }
+        if (state === 0) {
+          return state;
+        }
+        return state - 1;
+      }
+    case 'moveRight':
+      {
+        if (state === null) {
+          return action.total - 1;
+        }
+        if (state === action.total - 1) {
+          return state;
+        }
+        return state + 1;
+      }
+    default:
+      {
+        return null;
+      }
+  }
+}

package/styled-components/cjs/components/Select/reducers/focusedPathReducer.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusedPathReducer = focusedPathReducer;
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function focusedPathReducer(state, action) {
+  switch (action.type) {
+    case 'reset':
+      {
+        return [];
+      }
+    case 'set_initial_focus':
+      {
+        return [0];
+      }
+    case 'change_last_focus':
+      {
+        return [].concat(_toConsumableArray(state.slice(0, -1)), [action.value]);
+      }
+    case 'add_focus':
+      {
+        return [].concat(_toConsumableArray(state), [action.value]);
+      }
+    case 'return_prev_focus':
+      {
+        return _toConsumableArray(state.slice(0, -1));
+      }
+    default:
+      {
+        return state;
+      }
+  }
+}

package/styled-components/cjs/components/Select/reducers/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _pathReducer = /*#__PURE__*/require("./pathReducer");
+Object.keys(_pathReducer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pathReducer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _pathReducer[key];
+    }
+  });
+});
+var _focusedPathReducer = /*#__PURE__*/require("./focusedPathReducer");
+Object.keys(_focusedPathReducer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _focusedPathReducer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _focusedPathReducer[key];
+    }
+  });
+});
+var _focusedChipIndexReducer = /*#__PURE__*/require("./focusedChipIndexReducer");
+Object.keys(_focusedChipIndexReducer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _focusedChipIndexReducer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _focusedChipIndexReducer[key];
+    }
+  });
+});

package/styled-components/cjs/components/Select/reducers/pathReducer.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pathReducer = pathReducer;
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function pathReducer(state, action) {
+  switch (action.type) {
+    case 'reset':
+      {
+        return [];
+      }
+    case 'opened_first_level':
+      {
+        return ['root'];
+      }
+    case 'added_next_level':
+      {
+        return [].concat(_toConsumableArray(state), [action.value]);
+      }
+    case 'removed_last_level':
+      {
+        return _toConsumableArray(state.slice(0, -1));
+      }
+    case 'changed_on_level':
+      {
+        return [].concat(_toConsumableArray(state.slice(0, action.level)), [action.value]);
+      }
+    case 'cut_by_level':
+      {
+        return state.slice(0, action.level);
+      }
+    default:
+      {
+        return state;
+      }
+  }
+}

package/styled-components/cjs/components/Select/utils/getButtonLabel.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getButtonLabel = void 0;
+var _utils = /*#__PURE__*/require("../../../utils");
+var getLabel = function getLabel(_ref) {
+  var renderValue = _ref.renderValue,
+    value = _ref.value,
+    valueToItemMap = _ref.valueToItemMap;
+  var _ref2 = valueToItemMap.get(value.toString()),
+    label = _ref2.label;
+  return renderValue ? renderValue(value, label) : label;
+};
+var getButtonLabel = exports.getButtonLabel = function getButtonLabel(_ref3) {
+  var value = _ref3.value,
+    label = _ref3.label,
+    isTargetAmount = _ref3.isTargetAmount,
+    multiselect = _ref3.multiselect,
+    valueToItemMap = _ref3.valueToItemMap,
+    renderValue = _ref3.renderValue;
+  if ((0, _utils.isEmpty)(value)) {
+    return label;
+  }
+  if (multiselect && isTargetAmount) {
+    return "\u0412\u044B\u0431\u0440\u0430\u043D\u043E: ".concat(value.length);
+  }
+  if (multiselect && Array.isArray(value)) {
+    return value.map(function (itemValue) {
+      return getLabel({
+        renderValue: renderValue,
+        value: itemValue,
+        valueToItemMap: valueToItemMap
+      });
+    }).join(', ');
+  }
+  return getLabel({
+    renderValue: renderValue,
+    value: value,
+    valueToItemMap: valueToItemMap
+  });
+};

package/styled-components/cjs/components/Select/utils/getCorrectHeight.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCorrectHeight = void 0;
+var getCorrectHeight = exports.getCorrectHeight = function getCorrectHeight(listHeight) {
+  if (Number.isNaN(Number(listHeight))) {
+    return listHeight.toString();
+  }
+  return "".concat(listHeight, "rem");
+};

package/styled-components/cjs/components/Select/utils/getView.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getView = void 0;
+var getView = exports.getView = function getView(view, status) {
+  switch (status) {
+    case 'success':
+      {
+        return 'positive';
+      }
+    case 'warning':
+      {
+        return 'warning';
+      }
+    case 'error':
+      {
+        return 'negative';
+      }
+    default:
+      {
+        return view;
+      }
+  }
+};