first commit

frontend/node_modules/rc-overflow/lib/Item.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import type { ComponentType } from './RawItem';
+export interface ItemProps<ItemType> extends React.HTMLAttributes<any> {
+    prefixCls: string;
+    item?: ItemType;
+    className?: string;
+    style?: React.CSSProperties;
+    renderItem?: (item: ItemType, info: {
+        index: number;
+    }) => React.ReactNode;
+    responsive?: boolean;
+    /**
+     * @private To make node structure stable. We need keep wrap with ResizeObserver.
+     * But disable it when it's no need to real measure.
+     */
+    responsiveDisabled?: boolean;
+    itemKey?: React.Key;
+    registerSize: (key: React.Key, width: number | null) => void;
+    children?: React.ReactNode;
+    display: boolean;
+    order: number;
+    component?: ComponentType;
+    invalidate?: boolean;
+}
+declare const Item: React.ForwardRefExoticComponent<ItemProps<unknown> & React.RefAttributes<any>>;
+export default Item;

frontend/node_modules/rc-overflow/lib/Item.js

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+var _excluded = ["prefixCls", "invalidate", "item", "renderItem", "responsive", "responsiveDisabled", "registerSize", "itemKey", "className", "style", "children", "display", "order", "component"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// Use shared variable to save bundle size
+var UNDEFINED = undefined;
+function InternalItem(props, ref) {
+  var prefixCls = props.prefixCls,
+    invalidate = props.invalidate,
+    item = props.item,
+    renderItem = props.renderItem,
+    responsive = props.responsive,
+    responsiveDisabled = props.responsiveDisabled,
+    registerSize = props.registerSize,
+    itemKey = props.itemKey,
+    className = props.className,
+    style = props.style,
+    children = props.children,
+    display = props.display,
+    order = props.order,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var mergedHidden = responsive && !display;
+
+  // ================================ Effect ================================
+  function internalRegisterSize(width) {
+    registerSize(itemKey, width);
+  }
+  React.useEffect(function () {
+    return function () {
+      internalRegisterSize(null);
+    };
+  }, []);
+
+  // ================================ Render ================================
+  var childNode = renderItem && item !== UNDEFINED ? renderItem(item, {
+    index: order
+  }) : children;
+  var overflowStyle;
+  if (!invalidate) {
+    overflowStyle = {
+      opacity: mergedHidden ? 0 : 1,
+      height: mergedHidden ? 0 : UNDEFINED,
+      overflowY: mergedHidden ? 'hidden' : UNDEFINED,
+      order: responsive ? order : UNDEFINED,
+      pointerEvents: mergedHidden ? 'none' : UNDEFINED,
+      position: mergedHidden ? 'absolute' : UNDEFINED
+    };
+  }
+  var overflowProps = {};
+  if (mergedHidden) {
+    overflowProps['aria-hidden'] = true;
+  }
+  var itemNode = /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({
+    className: (0, _classnames.default)(!invalidate && prefixCls, className),
+    style: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, overflowStyle), style)
+  }, overflowProps, restProps, {
+    ref: ref
+  }), childNode);
+  if (responsive) {
+    itemNode = /*#__PURE__*/React.createElement(_rcResizeObserver.default, {
+      onResize: function onResize(_ref) {
+        var offsetWidth = _ref.offsetWidth;
+        internalRegisterSize(offsetWidth);
+      },
+      disabled: responsiveDisabled
+    }, itemNode);
+  }
+  return itemNode;
+}
+var Item = /*#__PURE__*/React.forwardRef(InternalItem);
+Item.displayName = 'Item';
+var _default = exports.default = Item;

frontend/node_modules/rc-overflow/lib/Overflow.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import type { ComponentType } from './RawItem';
+import RawItem from './RawItem';
+declare const RESPONSIVE: "responsive";
+declare const INVALIDATE: "invalidate";
+export { OverflowContext } from './context';
+export type { ComponentType } from './RawItem';
+export interface OverflowProps<ItemType> extends Omit<React.HTMLAttributes<any>, 'prefix'> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    data?: ItemType[];
+    itemKey?: React.Key | ((item: ItemType) => React.Key);
+    /** Used for `responsive`. It will limit render node to avoid perf issue */
+    itemWidth?: number;
+    renderItem?: (item: ItemType, info: {
+        index: number;
+    }) => React.ReactNode;
+    /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+    renderRawItem?: (item: ItemType, index: number) => React.ReactElement;
+    maxCount?: number | typeof RESPONSIVE | typeof INVALIDATE;
+    renderRest?: React.ReactNode | ((omittedItems: ItemType[]) => React.ReactNode);
+    /** @private Do not use in your production. Render raw node that need wrap Item by developer self */
+    renderRawRest?: (omittedItems: ItemType[]) => React.ReactElement;
+    prefix?: React.ReactNode;
+    suffix?: React.ReactNode;
+    component?: ComponentType;
+    itemComponent?: ComponentType;
+    /** @private This API may be refactor since not well design */
+    onVisibleChange?: (visibleCount: number) => void;
+    /** When set to `full`, ssr will render full items by default and remove at client side */
+    ssr?: 'full';
+}
+type ForwardOverflowType = <ItemType = any>(props: React.PropsWithChildren<OverflowProps<ItemType>> & {
+    ref?: React.Ref<HTMLDivElement>;
+}) => React.ReactElement;
+type FilledOverflowType = ForwardOverflowType & {
+    Item: typeof RawItem;
+    RESPONSIVE: typeof RESPONSIVE;
+    /** Will work as normal `component`. Skip patch props like `prefixCls`. */
+    INVALIDATE: typeof INVALIDATE;
+};
+declare const _default: FilledOverflowType;
+export default _default;

frontend/node_modules/rc-overflow/lib/Overflow.js

@@ -0,0 +1,329 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "OverflowContext", {
+  enumerable: true,
+  get: function get() {
+    return _context.OverflowContext;
+  }
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = _interopRequireWildcard(require("react"));
+var React = _react;
+var _classnames = _interopRequireDefault(require("classnames"));
+var _rcResizeObserver = _interopRequireDefault(require("rc-resize-observer"));
+var _useLayoutEffect = _interopRequireDefault(require("rc-util/lib/hooks/useLayoutEffect"));
+var _Item = _interopRequireDefault(require("./Item"));
+var _useEffectState13 = _interopRequireWildcard(require("./hooks/useEffectState"));
+var _RawItem = _interopRequireDefault(require("./RawItem"));
+var _context = require("./context");
+var _excluded = ["prefixCls", "data", "renderItem", "renderRawItem", "itemKey", "itemWidth", "ssr", "style", "className", "maxCount", "renderRest", "renderRawRest", "prefix", "suffix", "component", "itemComponent", "onVisibleChange"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var RESPONSIVE = 'responsive';
+var INVALIDATE = 'invalidate';
+function defaultRenderRest(omittedItems) {
+  return "+ ".concat(omittedItems.length, " ...");
+}
+function Overflow(props, ref) {
+  var _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'rc-overflow' : _props$prefixCls,
+    _props$data = props.data,
+    data = _props$data === void 0 ? [] : _props$data,
+    renderItem = props.renderItem,
+    renderRawItem = props.renderRawItem,
+    itemKey = props.itemKey,
+    _props$itemWidth = props.itemWidth,
+    itemWidth = _props$itemWidth === void 0 ? 10 : _props$itemWidth,
+    ssr = props.ssr,
+    style = props.style,
+    className = props.className,
+    maxCount = props.maxCount,
+    renderRest = props.renderRest,
+    renderRawRest = props.renderRawRest,
+    prefix = props.prefix,
+    suffix = props.suffix,
+    _props$component = props.component,
+    Component = _props$component === void 0 ? 'div' : _props$component,
+    itemComponent = props.itemComponent,
+    onVisibleChange = props.onVisibleChange,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+  var fullySSR = ssr === 'full';
+  var notifyEffectUpdate = (0, _useEffectState13.useBatcher)();
+  var _useEffectState = (0, _useEffectState13.default)(notifyEffectUpdate, null),
+    _useEffectState2 = (0, _slicedToArray2.default)(_useEffectState, 2),
+    containerWidth = _useEffectState2[0],
+    setContainerWidth = _useEffectState2[1];
+  var mergedContainerWidth = containerWidth || 0;
+  var _useEffectState3 = (0, _useEffectState13.default)(notifyEffectUpdate, new Map()),
+    _useEffectState4 = (0, _slicedToArray2.default)(_useEffectState3, 2),
+    itemWidths = _useEffectState4[0],
+    setItemWidths = _useEffectState4[1];
+  var _useEffectState5 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState6 = (0, _slicedToArray2.default)(_useEffectState5, 2),
+    prevRestWidth = _useEffectState6[0],
+    setPrevRestWidth = _useEffectState6[1];
+  var _useEffectState7 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState8 = (0, _slicedToArray2.default)(_useEffectState7, 2),
+    restWidth = _useEffectState8[0],
+    setRestWidth = _useEffectState8[1];
+  var _useEffectState9 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState10 = (0, _slicedToArray2.default)(_useEffectState9, 2),
+    prefixWidth = _useEffectState10[0],
+    setPrefixWidth = _useEffectState10[1];
+  var _useEffectState11 = (0, _useEffectState13.default)(notifyEffectUpdate, 0),
+    _useEffectState12 = (0, _slicedToArray2.default)(_useEffectState11, 2),
+    suffixWidth = _useEffectState12[0],
+    setSuffixWidth = _useEffectState12[1];
+  var _useState = (0, _react.useState)(null),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    suffixFixedStart = _useState2[0],
+    setSuffixFixedStart = _useState2[1];
+  var _useState3 = (0, _react.useState)(null),
+    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
+    displayCount = _useState4[0],
+    setDisplayCount = _useState4[1];
+  var mergedDisplayCount = React.useMemo(function () {
+    if (displayCount === null && fullySSR) {
+      return Number.MAX_SAFE_INTEGER;
+    }
+    return displayCount || 0;
+  }, [displayCount, containerWidth]);
+  var _useState5 = (0, _react.useState)(false),
+    _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
+    restReady = _useState6[0],
+    setRestReady = _useState6[1];
+  var itemPrefixCls = "".concat(prefixCls, "-item");
+
+  // Always use the max width to avoid blink
+  var mergedRestWidth = Math.max(prevRestWidth, restWidth);
+
+  // ================================= Data =================================
+  var isResponsive = maxCount === RESPONSIVE;
+  var shouldResponsive = data.length && isResponsive;
+  var invalidate = maxCount === INVALIDATE;
+
+  /**
+   * When is `responsive`, we will always render rest node to get the real width of it for calculation
+   */
+  var showRest = shouldResponsive || typeof maxCount === 'number' && data.length > maxCount;
+  var mergedData = (0, _react.useMemo)(function () {
+    var items = data;
+    if (shouldResponsive) {
+      if (containerWidth === null && fullySSR) {
+        items = data;
+      } else {
+        items = data.slice(0, Math.min(data.length, mergedContainerWidth / itemWidth));
+      }
+    } else if (typeof maxCount === 'number') {
+      items = data.slice(0, maxCount);
+    }
+    return items;
+  }, [data, itemWidth, containerWidth, maxCount, shouldResponsive]);
+  var omittedItems = (0, _react.useMemo)(function () {
+    if (shouldResponsive) {
+      return data.slice(mergedDisplayCount + 1);
+    }
+    return data.slice(mergedData.length);
+  }, [data, mergedData, shouldResponsive, mergedDisplayCount]);
+
+  // ================================= Item =================================
+  var getKey = (0, _react.useCallback)(function (item, index) {
+    var _ref;
+    if (typeof itemKey === 'function') {
+      return itemKey(item);
+    }
+    return (_ref = itemKey && (item === null || item === void 0 ? void 0 : item[itemKey])) !== null && _ref !== void 0 ? _ref : index;
+  }, [itemKey]);
+  var mergedRenderItem = (0, _react.useCallback)(renderItem || function (item) {
+    return item;
+  }, [renderItem]);
+  function updateDisplayCount(count, suffixFixedStartVal, notReady) {
+    // React 18 will sync render even when the value is same in some case.
+    // We take `mergedData` as deps which may cause dead loop if it's dynamic generate.
+    // ref: https://github.com/ant-design/ant-design/issues/36559
+    if (displayCount === count && (suffixFixedStartVal === undefined || suffixFixedStartVal === suffixFixedStart)) {
+      return;
+    }
+    setDisplayCount(count);
+    if (!notReady) {
+      setRestReady(count < data.length - 1);
+      onVisibleChange === null || onVisibleChange === void 0 || onVisibleChange(count);
+    }
+    if (suffixFixedStartVal !== undefined) {
+      setSuffixFixedStart(suffixFixedStartVal);
+    }
+  }
+
+  // ================================= Size =================================
+  function onOverflowResize(_, element) {
+    setContainerWidth(element.clientWidth);
+  }
+  function registerSize(key, width) {
+    setItemWidths(function (origin) {
+      var clone = new Map(origin);
+      if (width === null) {
+        clone.delete(key);
+      } else {
+        clone.set(key, width);
+      }
+      return clone;
+    });
+  }
+  function registerOverflowSize(_, width) {
+    setRestWidth(width);
+    setPrevRestWidth(restWidth);
+  }
+  function registerPrefixSize(_, width) {
+    setPrefixWidth(width);
+  }
+  function registerSuffixSize(_, width) {
+    setSuffixWidth(width);
+  }
+
+  // ================================ Effect ================================
+  function getItemWidth(index) {
+    return itemWidths.get(getKey(mergedData[index], index));
+  }
+  (0, _useLayoutEffect.default)(function () {
+    if (mergedContainerWidth && typeof mergedRestWidth === 'number' && mergedData) {
+      var totalWidth = prefixWidth + suffixWidth;
+      var len = mergedData.length;
+      var lastIndex = len - 1;
+
+      // When data count change to 0, reset this since not loop will reach
+      if (!len) {
+        updateDisplayCount(0, null);
+        return;
+      }
+      for (var i = 0; i < len; i += 1) {
+        var currentItemWidth = getItemWidth(i);
+
+        // Fully will always render
+        if (fullySSR) {
+          currentItemWidth = currentItemWidth || 0;
+        }
+
+        // Break since data not ready
+        if (currentItemWidth === undefined) {
+          updateDisplayCount(i - 1, undefined, true);
+          break;
+        }
+
+        // Find best match
+        totalWidth += currentItemWidth;
+        if (
+        // Only one means `totalWidth` is the final width
+        lastIndex === 0 && totalWidth <= mergedContainerWidth ||
+        // Last two width will be the final width
+        i === lastIndex - 1 && totalWidth + getItemWidth(lastIndex) <= mergedContainerWidth) {
+          // Additional check if match the end
+          updateDisplayCount(lastIndex, null);
+          break;
+        } else if (totalWidth + mergedRestWidth > mergedContainerWidth) {
+          // Can not hold all the content to show rest
+          updateDisplayCount(i - 1, totalWidth - currentItemWidth - suffixWidth + restWidth);
+          break;
+        }
+      }
+      if (suffix && getItemWidth(0) + suffixWidth > mergedContainerWidth) {
+        setSuffixFixedStart(null);
+      }
+    }
+  }, [mergedContainerWidth, itemWidths, restWidth, prefixWidth, suffixWidth, getKey, mergedData]);
+
+  // ================================ Render ================================
+  var displayRest = restReady && !!omittedItems.length;
+  var suffixStyle = {};
+  if (suffixFixedStart !== null && shouldResponsive) {
+    suffixStyle = {
+      position: 'absolute',
+      left: suffixFixedStart,
+      top: 0
+    };
+  }
+  var itemSharedProps = {
+    prefixCls: itemPrefixCls,
+    responsive: shouldResponsive,
+    component: itemComponent,
+    invalidate: invalidate
+  };
+
+  // >>>>> Choice render fun by `renderRawItem`
+  var internalRenderItemNode = renderRawItem ? function (item, index) {
+    var key = getKey(item, index);
+    return /*#__PURE__*/React.createElement(_context.OverflowContext.Provider, {
+      key: key,
+      value: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, itemSharedProps), {}, {
+        order: index,
+        item: item,
+        itemKey: key,
+        registerSize: registerSize,
+        display: index <= mergedDisplayCount
+      })
+    }, renderRawItem(item, index));
+  } : function (item, index) {
+    var key = getKey(item, index);
+    return /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, {
+      order: index,
+      key: key,
+      item: item,
+      renderItem: mergedRenderItem,
+      itemKey: key,
+      registerSize: registerSize,
+      display: index <= mergedDisplayCount
+    }));
+  };
+
+  // >>>>> Rest node
+  var restContextProps = {
+    order: displayRest ? mergedDisplayCount : Number.MAX_SAFE_INTEGER,
+    className: "".concat(itemPrefixCls, "-rest"),
+    registerSize: registerOverflowSize,
+    display: displayRest
+  };
+  var mergedRenderRest = renderRest || defaultRenderRest;
+  var restNode = renderRawRest ? /*#__PURE__*/React.createElement(_context.OverflowContext.Provider, {
+    value: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, itemSharedProps), restContextProps)
+  }, renderRawRest(omittedItems)) : /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, restContextProps), typeof mergedRenderRest === 'function' ? mergedRenderRest(omittedItems) : mergedRenderRest);
+  var overflowNode = /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({
+    className: (0, _classnames.default)(!invalidate && prefixCls, className),
+    style: style,
+    ref: ref
+  }, restProps), prefix && /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, {
+    responsive: isResponsive,
+    responsiveDisabled: !shouldResponsive,
+    order: -1,
+    className: "".concat(itemPrefixCls, "-prefix"),
+    registerSize: registerPrefixSize,
+    display: true
+  }), prefix), mergedData.map(internalRenderItemNode), showRest ? restNode : null, suffix && /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({}, itemSharedProps, {
+    responsive: isResponsive,
+    responsiveDisabled: !shouldResponsive,
+    order: mergedDisplayCount,
+    className: "".concat(itemPrefixCls, "-suffix"),
+    registerSize: registerSuffixSize,
+    display: true,
+    style: suffixStyle
+  }), suffix));
+  return isResponsive ? /*#__PURE__*/React.createElement(_rcResizeObserver.default, {
+    onResize: onOverflowResize,
+    disabled: !shouldResponsive
+  }, overflowNode) : overflowNode;
+}
+var ForwardOverflow = /*#__PURE__*/React.forwardRef(Overflow);
+ForwardOverflow.displayName = 'Overflow';
+ForwardOverflow.Item = _RawItem.default;
+ForwardOverflow.RESPONSIVE = RESPONSIVE;
+ForwardOverflow.INVALIDATE = INVALIDATE;
+
+// Convert to generic type
+var _default = exports.default = ForwardOverflow;

frontend/node_modules/rc-overflow/lib/RawItem.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+export type ComponentType = React.ComponentType<any> | React.ForwardRefExoticComponent<any> | React.FC<any> | keyof React.ReactHTML;
+export interface RawItemProps extends React.HTMLAttributes<any> {
+    component?: ComponentType;
+    children?: React.ReactNode;
+}
+declare const RawItem: React.ForwardRefExoticComponent<RawItemProps & React.RefAttributes<any>>;
+export default RawItem;

frontend/node_modules/rc-overflow/lib/RawItem.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var React = _interopRequireWildcard(require("react"));
+var _classnames = _interopRequireDefault(require("classnames"));
+var _Item = _interopRequireDefault(require("./Item"));
+var _context = require("./context");
+var _excluded = ["component"],
+  _excluded2 = ["className"],
+  _excluded3 = ["className"];
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+var InternalRawItem = function InternalRawItem(props, ref) {
+  var context = React.useContext(_context.OverflowContext);
+
+  // Render directly when context not provided
+  if (!context) {
+    var _props$component = props.component,
+      Component = _props$component === void 0 ? 'div' : _props$component,
+      _restProps = (0, _objectWithoutProperties2.default)(props, _excluded);
+    return /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({}, _restProps, {
+      ref: ref
+    }));
+  }
+  var contextClassName = context.className,
+    restContext = (0, _objectWithoutProperties2.default)(context, _excluded2);
+  var className = props.className,
+    restProps = (0, _objectWithoutProperties2.default)(props, _excluded3);
+
+  // Do not pass context to sub item to avoid multiple measure
+  return /*#__PURE__*/React.createElement(_context.OverflowContext.Provider, {
+    value: null
+  }, /*#__PURE__*/React.createElement(_Item.default, (0, _extends2.default)({
+    ref: ref,
+    className: (0, _classnames.default)(contextClassName, className)
+  }, restContext, restProps)));
+};
+var RawItem = /*#__PURE__*/React.forwardRef(InternalRawItem);
+RawItem.displayName = 'RawItem';
+var _default = exports.default = RawItem;

frontend/node_modules/rc-overflow/lib/context.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export declare const OverflowContext: React.Context<{
+    prefixCls: string;
+    responsive: boolean;
+    order: number;
+    registerSize: (key: React.Key, width: number | null) => void;
+    display: boolean;
+    invalidate: boolean;
+    item?: any;
+    itemKey?: React.Key;
+    className?: string;
+}>;

frontend/node_modules/rc-overflow/lib/context.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OverflowContext = void 0;
+var _react = _interopRequireDefault(require("react"));
+var OverflowContext = exports.OverflowContext = /*#__PURE__*/_react.default.createContext(null);

frontend/node_modules/rc-overflow/lib/hooks/channelUpdate.d.ts

@@ -0,0 +1 @@
+export default function channelUpdate(callback: VoidFunction): void;

frontend/node_modules/rc-overflow/lib/hooks/channelUpdate.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = channelUpdate;
+var _raf = _interopRequireDefault(require("rc-util/lib/raf"));
+function channelUpdate(callback) {
+  if (typeof MessageChannel === 'undefined') {
+    (0, _raf.default)(callback);
+  } else {
+    var channel = new MessageChannel();
+    channel.port1.onmessage = function () {
+      return callback();
+    };
+    channel.port2.postMessage(undefined);
+  }
+}

frontend/node_modules/rc-overflow/lib/hooks/useEffectState.d.ts

@@ -0,0 +1,12 @@
+type Updater<T> = T | ((origin: T) => T);
+type UpdateCallbackFunc = VoidFunction;
+type NotifyEffectUpdate = (callback: UpdateCallbackFunc) => void;
+/**
+ * Batcher for record any `useEffectState` need update.
+ */
+export declare function useBatcher(): NotifyEffectUpdate;
+/**
+ * Trigger state update by `useLayoutEffect` to save perf.
+ */
+export default function useEffectState<T extends string | number | object>(notifyEffectUpdate: NotifyEffectUpdate, defaultValue?: T): [T, (value: Updater<T>) => void];
+export {};

frontend/node_modules/rc-overflow/lib/hooks/useEffectState.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useEffectState;
+exports.useBatcher = useBatcher;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _useEvent = _interopRequireDefault(require("rc-util/lib/hooks/useEvent"));
+var React = _interopRequireWildcard(require("react"));
+var _reactDom = require("react-dom");
+var _channelUpdate = _interopRequireDefault(require("./channelUpdate"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Batcher for record any `useEffectState` need update.
+ */
+function useBatcher() {
+  // Updater Trigger
+  var updateFuncRef = React.useRef(null);
+
+  // Notify update
+  var notifyEffectUpdate = function notifyEffectUpdate(callback) {
+    if (!updateFuncRef.current) {
+      updateFuncRef.current = [];
+      (0, _channelUpdate.default)(function () {
+        (0, _reactDom.unstable_batchedUpdates)(function () {
+          updateFuncRef.current.forEach(function (fn) {
+            fn();
+          });
+          updateFuncRef.current = null;
+        });
+      });
+    }
+    updateFuncRef.current.push(callback);
+  };
+  return notifyEffectUpdate;
+}
+
+/**
+ * Trigger state update by `useLayoutEffect` to save perf.
+ */
+function useEffectState(notifyEffectUpdate, defaultValue) {
+  // Value
+  var _React$useState = React.useState(defaultValue),
+    _React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
+    stateValue = _React$useState2[0],
+    setStateValue = _React$useState2[1];
+
+  // Set State
+  var setEffectVal = (0, _useEvent.default)(function (nextValue) {
+    notifyEffectUpdate(function () {
+      setStateValue(nextValue);
+    });
+  });
+  return [stateValue, setEffectVal];
+}

frontend/node_modules/rc-overflow/lib/index.d.ts

@@ -0,0 +1,4 @@
+import Overflow from './Overflow';
+import type { OverflowProps } from './Overflow';
+export type { OverflowProps };
+export default Overflow;

frontend/node_modules/rc-overflow/lib/index.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Overflow = _interopRequireDefault(require("./Overflow"));
+var _default = exports.default = _Overflow.default;