add all frontend files

node_modules/rc-dropdown/es/Dropdown.d.ts

@@ -0,0 +1,28 @@
+import type { TriggerProps } from '@rc-component/trigger';
+import type { ActionType, AlignType, AnimationType, BuildInPlacements } from '@rc-component/trigger/lib/interface';
+import React from 'react';
+import Placements from './placements';
+export interface DropdownProps extends Pick<TriggerProps, 'getPopupContainer' | 'children' | 'mouseEnterDelay' | 'mouseLeaveDelay' | 'onPopupAlign' | 'builtinPlacements' | 'autoDestroy'> {
+    minOverlayWidthMatchTrigger?: boolean;
+    arrow?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+    onOverlayClick?: (e: Event) => void;
+    prefixCls?: string;
+    transitionName?: string;
+    overlayClassName?: string;
+    openClassName?: string;
+    animation?: AnimationType;
+    align?: AlignType;
+    overlayStyle?: React.CSSProperties;
+    placement?: keyof typeof Placements;
+    placements?: BuildInPlacements;
+    overlay?: (() => React.ReactElement) | React.ReactElement;
+    trigger?: ActionType | ActionType[];
+    alignPoint?: boolean;
+    showAction?: ActionType[];
+    hideAction?: ActionType[];
+    visible?: boolean;
+    autoFocus?: boolean;
+}
+declare const _default: React.ForwardRefExoticComponent<DropdownProps & React.RefAttributes<unknown>>;
+export default _default;

node_modules/rc-dropdown/es/Dropdown.js

@@ -0,0 +1,127 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["arrow", "prefixCls", "transitionName", "animation", "align", "placement", "placements", "getPopupContainer", "showAction", "hideAction", "overlayClassName", "overlayStyle", "visible", "trigger", "autoFocus", "overlay", "children", "onVisibleChange"];
+import Trigger from '@rc-component/trigger';
+import classNames from 'classnames';
+import { composeRef, getNodeRef, supportRef } from "rc-util/es/ref";
+import React from 'react';
+import useAccessibility from "./hooks/useAccessibility";
+import Overlay from "./Overlay";
+import Placements from "./placements";
+function Dropdown(props, ref) {
+  var _children$props;
+  var _props$arrow = props.arrow,
+    arrow = _props$arrow === void 0 ? false : _props$arrow,
+    _props$prefixCls = props.prefixCls,
+    prefixCls = _props$prefixCls === void 0 ? 'rc-dropdown' : _props$prefixCls,
+    transitionName = props.transitionName,
+    animation = props.animation,
+    align = props.align,
+    _props$placement = props.placement,
+    placement = _props$placement === void 0 ? 'bottomLeft' : _props$placement,
+    _props$placements = props.placements,
+    placements = _props$placements === void 0 ? Placements : _props$placements,
+    getPopupContainer = props.getPopupContainer,
+    showAction = props.showAction,
+    hideAction = props.hideAction,
+    overlayClassName = props.overlayClassName,
+    overlayStyle = props.overlayStyle,
+    visible = props.visible,
+    _props$trigger = props.trigger,
+    trigger = _props$trigger === void 0 ? ['hover'] : _props$trigger,
+    autoFocus = props.autoFocus,
+    overlay = props.overlay,
+    children = props.children,
+    onVisibleChange = props.onVisibleChange,
+    otherProps = _objectWithoutProperties(props, _excluded);
+  var _React$useState = React.useState(),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    triggerVisible = _React$useState2[0],
+    setTriggerVisible = _React$useState2[1];
+  var mergedVisible = 'visible' in props ? visible : triggerVisible;
+  var triggerRef = React.useRef(null);
+  var overlayRef = React.useRef(null);
+  var childRef = React.useRef(null);
+  React.useImperativeHandle(ref, function () {
+    return triggerRef.current;
+  });
+  var handleVisibleChange = function handleVisibleChange(newVisible) {
+    setTriggerVisible(newVisible);
+    onVisibleChange === null || onVisibleChange === void 0 || onVisibleChange(newVisible);
+  };
+  useAccessibility({
+    visible: mergedVisible,
+    triggerRef: childRef,
+    onVisibleChange: handleVisibleChange,
+    autoFocus: autoFocus,
+    overlayRef: overlayRef
+  });
+  var onClick = function onClick(e) {
+    var onOverlayClick = props.onOverlayClick;
+    setTriggerVisible(false);
+    if (onOverlayClick) {
+      onOverlayClick(e);
+    }
+  };
+  var getMenuElement = function getMenuElement() {
+    return /*#__PURE__*/React.createElement(Overlay, {
+      ref: overlayRef,
+      overlay: overlay,
+      prefixCls: prefixCls,
+      arrow: arrow
+    });
+  };
+  var getMenuElementOrLambda = function getMenuElementOrLambda() {
+    if (typeof overlay === 'function') {
+      return getMenuElement;
+    }
+    return getMenuElement();
+  };
+  var getMinOverlayWidthMatchTrigger = function getMinOverlayWidthMatchTrigger() {
+    var minOverlayWidthMatchTrigger = props.minOverlayWidthMatchTrigger,
+      alignPoint = props.alignPoint;
+    if ('minOverlayWidthMatchTrigger' in props) {
+      return minOverlayWidthMatchTrigger;
+    }
+    return !alignPoint;
+  };
+  var getOpenClassName = function getOpenClassName() {
+    var openClassName = props.openClassName;
+    if (openClassName !== undefined) {
+      return openClassName;
+    }
+    return "".concat(prefixCls, "-open");
+  };
+  var childrenNode = /*#__PURE__*/React.cloneElement(children, {
+    className: classNames((_children$props = children.props) === null || _children$props === void 0 ? void 0 : _children$props.className, mergedVisible && getOpenClassName()),
+    ref: supportRef(children) ? composeRef(childRef, getNodeRef(children)) : undefined
+  });
+  var triggerHideAction = hideAction;
+  if (!triggerHideAction && trigger.indexOf('contextMenu') !== -1) {
+    triggerHideAction = ['click'];
+  }
+  return /*#__PURE__*/React.createElement(Trigger, _extends({
+    builtinPlacements: placements
+  }, otherProps, {
+    prefixCls: prefixCls,
+    ref: triggerRef,
+    popupClassName: classNames(overlayClassName, _defineProperty({}, "".concat(prefixCls, "-show-arrow"), arrow)),
+    popupStyle: overlayStyle,
+    action: trigger,
+    showAction: showAction,
+    hideAction: triggerHideAction,
+    popupPlacement: placement,
+    popupAlign: align,
+    popupTransitionName: transitionName,
+    popupAnimation: animation,
+    popupVisible: mergedVisible,
+    stretch: getMinOverlayWidthMatchTrigger() ? 'minWidth' : '',
+    popup: getMenuElementOrLambda(),
+    onPopupVisibleChange: handleVisibleChange,
+    onPopupClick: onClick,
+    getPopupContainer: getPopupContainer
+  }), childrenNode);
+}
+export default /*#__PURE__*/React.forwardRef(Dropdown);

node_modules/rc-dropdown/es/Overlay.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { DropdownProps } from './Dropdown';
+export type OverlayProps = Pick<DropdownProps, 'overlay' | 'arrow' | 'prefixCls'>;
+declare const Overlay: React.ForwardRefExoticComponent<OverlayProps & React.RefAttributes<HTMLElement>>;
+export default Overlay;

node_modules/rc-dropdown/es/Overlay.js

@@ -0,0 +1,23 @@
+import { composeRef, getNodeRef, supportRef } from "rc-util/es/ref";
+import React, { forwardRef, useMemo } from 'react';
+var Overlay = /*#__PURE__*/forwardRef(function (props, ref) {
+  var overlay = props.overlay,
+    arrow = props.arrow,
+    prefixCls = props.prefixCls;
+  var overlayNode = useMemo(function () {
+    var overlayElement;
+    if (typeof overlay === 'function') {
+      overlayElement = overlay();
+    } else {
+      overlayElement = overlay;
+    }
+    return overlayElement;
+  }, [overlay]);
+  var composedRef = composeRef(ref, getNodeRef(overlayNode));
+  return /*#__PURE__*/React.createElement(React.Fragment, null, arrow && /*#__PURE__*/React.createElement("div", {
+    className: "".concat(prefixCls, "-arrow")
+  }), /*#__PURE__*/React.cloneElement(overlayNode, {
+    ref: supportRef(overlayNode) ? composedRef : undefined
+  }));
+});
+export default Overlay;

node_modules/rc-dropdown/es/hooks/useAccessibility.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+interface UseAccessibilityProps {
+    visible: boolean;
+    triggerRef: React.RefObject<any>;
+    onVisibleChange?: (visible: boolean) => void;
+    autoFocus?: boolean;
+    overlayRef?: React.RefObject<any>;
+}
+export default function useAccessibility({ visible, triggerRef, onVisibleChange, autoFocus, overlayRef, }: UseAccessibilityProps): void;
+export {};

node_modules/rc-dropdown/es/hooks/useAccessibility.js

@@ -0,0 +1,65 @@
+import KeyCode from "rc-util/es/KeyCode";
+import raf from "rc-util/es/raf";
+import * as React from "react";
+var ESC = KeyCode.ESC,
+  TAB = KeyCode.TAB;
+export default function useAccessibility(_ref) {
+  var visible = _ref.visible,
+    triggerRef = _ref.triggerRef,
+    onVisibleChange = _ref.onVisibleChange,
+    autoFocus = _ref.autoFocus,
+    overlayRef = _ref.overlayRef;
+  var focusMenuRef = React.useRef(false);
+  var handleCloseMenuAndReturnFocus = function handleCloseMenuAndReturnFocus() {
+    if (visible) {
+      var _triggerRef$current, _triggerRef$current$f;
+      (_triggerRef$current = triggerRef.current) === null || _triggerRef$current === void 0 || (_triggerRef$current$f = _triggerRef$current.focus) === null || _triggerRef$current$f === void 0 || _triggerRef$current$f.call(_triggerRef$current);
+      onVisibleChange === null || onVisibleChange === void 0 || onVisibleChange(false);
+    }
+  };
+  var focusMenu = function focusMenu() {
+    var _overlayRef$current;
+    if ((_overlayRef$current = overlayRef.current) !== null && _overlayRef$current !== void 0 && _overlayRef$current.focus) {
+      overlayRef.current.focus();
+      focusMenuRef.current = true;
+      return true;
+    }
+    return false;
+  };
+  var handleKeyDown = function handleKeyDown(event) {
+    switch (event.keyCode) {
+      case ESC:
+        handleCloseMenuAndReturnFocus();
+        break;
+      case TAB:
+        {
+          var focusResult = false;
+          if (!focusMenuRef.current) {
+            focusResult = focusMenu();
+          }
+          if (focusResult) {
+            event.preventDefault();
+          } else {
+            handleCloseMenuAndReturnFocus();
+          }
+          break;
+        }
+    }
+  };
+  React.useEffect(function () {
+    if (visible) {
+      window.addEventListener("keydown", handleKeyDown);
+      if (autoFocus) {
+        // FIXME: hack with raf
+        raf(focusMenu, 3);
+      }
+      return function () {
+        window.removeEventListener("keydown", handleKeyDown);
+        focusMenuRef.current = false;
+      };
+    }
+    return function () {
+      focusMenuRef.current = false;
+    };
+  }, [visible]); // eslint-disable-line react-hooks/exhaustive-deps
+}

node_modules/rc-dropdown/es/index.d.ts

@@ -0,0 +1,5 @@
+export type { TriggerProps } from '@rc-component/trigger';
+export type { DropdownProps } from './Dropdown';
+export type { OverlayProps } from './Overlay';
+import Dropdown from './Dropdown';
+export default Dropdown;

node_modules/rc-dropdown/es/index.js

@@ -0,0 +1,2 @@
+import Dropdown from "./Dropdown";
+export default Dropdown;

node_modules/rc-dropdown/es/placements.d.ts

@@ -0,0 +1,57 @@
+declare const placements: {
+    topLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    top: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    topRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomLeft: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottom: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+    bottomRight: {
+        points: string[];
+        overflow: {
+            adjustX: number;
+            adjustY: number;
+        };
+        offset: number[];
+        targetOffset: number[];
+    };
+};
+export default placements;

node_modules/rc-dropdown/es/placements.js

@@ -0,0 +1,44 @@
+var autoAdjustOverflow = {
+  adjustX: 1,
+  adjustY: 1
+};
+var targetOffset = [0, 0];
+var placements = {
+  topLeft: {
+    points: ['bl', 'tl'],
+    overflow: autoAdjustOverflow,
+    offset: [0, -4],
+    targetOffset: targetOffset
+  },
+  top: {
+    points: ['bc', 'tc'],
+    overflow: autoAdjustOverflow,
+    offset: [0, -4],
+    targetOffset: targetOffset
+  },
+  topRight: {
+    points: ['br', 'tr'],
+    overflow: autoAdjustOverflow,
+    offset: [0, -4],
+    targetOffset: targetOffset
+  },
+  bottomLeft: {
+    points: ['tl', 'bl'],
+    overflow: autoAdjustOverflow,
+    offset: [0, 4],
+    targetOffset: targetOffset
+  },
+  bottom: {
+    points: ['tc', 'bc'],
+    overflow: autoAdjustOverflow,
+    offset: [0, 4],
+    targetOffset: targetOffset
+  },
+  bottomRight: {
+    points: ['tr', 'br'],
+    overflow: autoAdjustOverflow,
+    offset: [0, 4],
+    targetOffset: targetOffset
+  }
+};
+export default placements;