add all frontend files

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

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import type { MenuMode } from '../interface';
+/**
+ * Get focusable elements from the element set under provided container
+ */
+export declare function getFocusableElements(container: HTMLElement, elements: Set<HTMLElement>): HTMLElement[];
+export declare const refreshElements: (keys: string[], id: string) => {
+    elements: Set<HTMLElement>;
+    key2element: Map<string, HTMLElement>;
+    element2key: Map<HTMLElement, string>;
+};
+export declare function useAccessibility<T extends HTMLElement>(mode: MenuMode, activeKey: string, isRtl: boolean, id: string, containerRef: React.RefObject<HTMLUListElement>, getKeys: () => string[], getKeyPath: (key: string, includeOverflow?: boolean) => string[], triggerActiveKey: (key: string) => void, triggerAccessibilityOpen: (key: string, open?: boolean) => void, originOnKeyDown?: React.KeyboardEventHandler<T>): React.KeyboardEventHandler<T>;

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

@@ -0,0 +1,270 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { getFocusNodeList } from "rc-util/es/Dom/focus";
+import KeyCode from "rc-util/es/KeyCode";
+import raf from "rc-util/es/raf";
+import * as React from 'react';
+import { getMenuId } from "../context/IdContext";
+// destruct to reduce minify size
+var LEFT = KeyCode.LEFT,
+  RIGHT = KeyCode.RIGHT,
+  UP = KeyCode.UP,
+  DOWN = KeyCode.DOWN,
+  ENTER = KeyCode.ENTER,
+  ESC = KeyCode.ESC,
+  HOME = KeyCode.HOME,
+  END = KeyCode.END;
+var ArrowKeys = [UP, DOWN, LEFT, RIGHT];
+function getOffset(mode, isRootLevel, isRtl, which) {
+  var _offsets;
+  var prev = 'prev';
+  var next = 'next';
+  var children = 'children';
+  var parent = 'parent';
+
+  // Inline enter is special that we use unique operation
+  if (mode === 'inline' && which === ENTER) {
+    return {
+      inlineTrigger: true
+    };
+  }
+  var inline = _defineProperty(_defineProperty({}, UP, prev), DOWN, next);
+  var horizontal = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, LEFT, isRtl ? next : prev), RIGHT, isRtl ? prev : next), DOWN, children), ENTER, children);
+  var vertical = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, UP, prev), DOWN, next), ENTER, children), ESC, parent), LEFT, isRtl ? children : parent), RIGHT, isRtl ? parent : children);
+  var offsets = {
+    inline: inline,
+    horizontal: horizontal,
+    vertical: vertical,
+    inlineSub: inline,
+    horizontalSub: vertical,
+    verticalSub: vertical
+  };
+  var type = (_offsets = offsets["".concat(mode).concat(isRootLevel ? '' : 'Sub')]) === null || _offsets === void 0 ? void 0 : _offsets[which];
+  switch (type) {
+    case prev:
+      return {
+        offset: -1,
+        sibling: true
+      };
+    case next:
+      return {
+        offset: 1,
+        sibling: true
+      };
+    case parent:
+      return {
+        offset: -1,
+        sibling: false
+      };
+    case children:
+      return {
+        offset: 1,
+        sibling: false
+      };
+    default:
+      return null;
+  }
+}
+function findContainerUL(element) {
+  var current = element;
+  while (current) {
+    if (current.getAttribute('data-menu-list')) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+
+  // Normally should not reach this line
+  /* istanbul ignore next */
+  return null;
+}
+
+/**
+ * Find focused element within element set provided
+ */
+function getFocusElement(activeElement, elements) {
+  var current = activeElement || document.activeElement;
+  while (current) {
+    if (elements.has(current)) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+  return null;
+}
+
+/**
+ * Get focusable elements from the element set under provided container
+ */
+export function getFocusableElements(container, elements) {
+  var list = getFocusNodeList(container, true);
+  return list.filter(function (ele) {
+    return elements.has(ele);
+  });
+}
+function getNextFocusElement(parentQueryContainer, elements, focusMenuElement) {
+  var offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;
+  // Key on the menu item will not get validate parent container
+  if (!parentQueryContainer) {
+    return null;
+  }
+
+  // List current level menu item elements
+  var sameLevelFocusableMenuElementList = getFocusableElements(parentQueryContainer, elements);
+
+  // Find next focus index
+  var count = sameLevelFocusableMenuElementList.length;
+  var focusIndex = sameLevelFocusableMenuElementList.findIndex(function (ele) {
+    return focusMenuElement === ele;
+  });
+  if (offset < 0) {
+    if (focusIndex === -1) {
+      focusIndex = count - 1;
+    } else {
+      focusIndex -= 1;
+    }
+  } else if (offset > 0) {
+    focusIndex += 1;
+  }
+  focusIndex = (focusIndex + count) % count;
+
+  // Focus menu item
+  return sameLevelFocusableMenuElementList[focusIndex];
+}
+export var refreshElements = function refreshElements(keys, id) {
+  var elements = new Set();
+  var key2element = new Map();
+  var element2key = new Map();
+  keys.forEach(function (key) {
+    var element = document.querySelector("[data-menu-id='".concat(getMenuId(id, key), "']"));
+    if (element) {
+      elements.add(element);
+      element2key.set(element, key);
+      key2element.set(key, element);
+    }
+  });
+  return {
+    elements: elements,
+    key2element: key2element,
+    element2key: element2key
+  };
+};
+export function useAccessibility(mode, activeKey, isRtl, id, containerRef, getKeys, getKeyPath, triggerActiveKey, triggerAccessibilityOpen, originOnKeyDown) {
+  var rafRef = React.useRef();
+  var activeRef = React.useRef();
+  activeRef.current = activeKey;
+  var cleanRaf = function cleanRaf() {
+    raf.cancel(rafRef.current);
+  };
+  React.useEffect(function () {
+    return function () {
+      cleanRaf();
+    };
+  }, []);
+  return function (e) {
+    var which = e.which;
+    if ([].concat(ArrowKeys, [ENTER, ESC, HOME, END]).includes(which)) {
+      var keys = getKeys();
+      var refreshedElements = refreshElements(keys, id);
+      var _refreshedElements = refreshedElements,
+        elements = _refreshedElements.elements,
+        key2element = _refreshedElements.key2element,
+        element2key = _refreshedElements.element2key;
+
+      // First we should find current focused MenuItem/SubMenu element
+      var activeElement = key2element.get(activeKey);
+      var focusMenuElement = getFocusElement(activeElement, elements);
+      var focusMenuKey = element2key.get(focusMenuElement);
+      var offsetObj = getOffset(mode, getKeyPath(focusMenuKey, true).length === 1, isRtl, which);
+
+      // Some mode do not have fully arrow operation like inline
+      if (!offsetObj && which !== HOME && which !== END) {
+        return;
+      }
+
+      // Arrow prevent default to avoid page scroll
+      if (ArrowKeys.includes(which) || [HOME, END].includes(which)) {
+        e.preventDefault();
+      }
+      var tryFocus = function tryFocus(menuElement) {
+        if (menuElement) {
+          var focusTargetElement = menuElement;
+
+          // Focus to link instead of menu item if possible
+          var link = menuElement.querySelector('a');
+          if (link !== null && link !== void 0 && link.getAttribute('href')) {
+            focusTargetElement = link;
+          }
+          var targetKey = element2key.get(menuElement);
+          triggerActiveKey(targetKey);
+
+          /**
+           * Do not `useEffect` here since `tryFocus` may trigger async
+           * which makes React sync update the `activeKey`
+           * that force render before `useRef` set the next activeKey
+           */
+          cleanRaf();
+          rafRef.current = raf(function () {
+            if (activeRef.current === targetKey) {
+              focusTargetElement.focus();
+            }
+          });
+        }
+      };
+      if ([HOME, END].includes(which) || offsetObj.sibling || !focusMenuElement) {
+        // ========================== Sibling ==========================
+        // Find walkable focus menu element container
+        var parentQueryContainer;
+        if (!focusMenuElement || mode === 'inline') {
+          parentQueryContainer = containerRef.current;
+        } else {
+          parentQueryContainer = findContainerUL(focusMenuElement);
+        }
+
+        // Get next focus element
+        var targetElement;
+        var focusableElements = getFocusableElements(parentQueryContainer, elements);
+        if (which === HOME) {
+          targetElement = focusableElements[0];
+        } else if (which === END) {
+          targetElement = focusableElements[focusableElements.length - 1];
+        } else {
+          targetElement = getNextFocusElement(parentQueryContainer, elements, focusMenuElement, offsetObj.offset);
+        }
+        // Focus menu item
+        tryFocus(targetElement);
+
+        // ======================= InlineTrigger =======================
+      } else if (offsetObj.inlineTrigger) {
+        // Inline trigger no need switch to sub menu item
+        triggerAccessibilityOpen(focusMenuKey);
+        // =========================== Level ===========================
+      } else if (offsetObj.offset > 0) {
+        triggerAccessibilityOpen(focusMenuKey, true);
+        cleanRaf();
+        rafRef.current = raf(function () {
+          // Async should resync elements
+          refreshedElements = refreshElements(keys, id);
+          var controlId = focusMenuElement.getAttribute('aria-controls');
+          var subQueryContainer = document.getElementById(controlId);
+
+          // Get sub focusable menu item
+          var targetElement = getNextFocusElement(subQueryContainer, refreshedElements.elements);
+
+          // Focus menu item
+          tryFocus(targetElement);
+        }, 5);
+      } else if (offsetObj.offset < 0) {
+        var keyPath = getKeyPath(focusMenuKey, true);
+        var parentKey = keyPath[keyPath.length - 2];
+        var parentMenuElement = key2element.get(parentKey);
+
+        // Focus menu item
+        triggerAccessibilityOpen(parentKey, false);
+        tryFocus(parentMenuElement);
+      }
+    }
+
+    // Pass origin key down event
+    originOnKeyDown === null || originOnKeyDown === void 0 || originOnKeyDown(e);
+  };
+}

node_modules/rc-menu/es/hooks/useActive.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import type { MenuHoverEventHandler } from '../interface';
+interface ActiveObj {
+    active: boolean;
+    onMouseEnter?: React.MouseEventHandler<HTMLElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLElement>;
+}
+export default function useActive(eventKey: string, disabled: boolean, onMouseEnter?: MenuHoverEventHandler, onMouseLeave?: MenuHoverEventHandler): ActiveObj;
+export {};

node_modules/rc-menu/es/hooks/useActive.js

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { MenuContext } from "../context/MenuContext";
+export default function useActive(eventKey, disabled, onMouseEnter, onMouseLeave) {
+  var _React$useContext = React.useContext(MenuContext),
+    activeKey = _React$useContext.activeKey,
+    onActive = _React$useContext.onActive,
+    onInactive = _React$useContext.onInactive;
+  var ret = {
+    active: activeKey === eventKey
+  };
+
+  // Skip when disabled
+  if (!disabled) {
+    ret.onMouseEnter = function (domEvent) {
+      onMouseEnter === null || onMouseEnter === void 0 || onMouseEnter({
+        key: eventKey,
+        domEvent: domEvent
+      });
+      onActive(eventKey);
+    };
+    ret.onMouseLeave = function (domEvent) {
+      onMouseLeave === null || onMouseLeave === void 0 || onMouseLeave({
+        key: eventKey,
+        domEvent: domEvent
+      });
+      onInactive(eventKey);
+    };
+  }
+  return ret;
+}

node_modules/rc-menu/es/hooks/useDirectionStyle.d.ts

@@ -0,0 +1,2 @@
+import * as React from 'react';
+export default function useDirectionStyle(level: number): React.CSSProperties;

node_modules/rc-menu/es/hooks/useDirectionStyle.js

@@ -0,0 +1,17 @@
+import * as React from 'react';
+import { MenuContext } from "../context/MenuContext";
+export default function useDirectionStyle(level) {
+  var _React$useContext = React.useContext(MenuContext),
+    mode = _React$useContext.mode,
+    rtl = _React$useContext.rtl,
+    inlineIndent = _React$useContext.inlineIndent;
+  if (mode !== 'inline') {
+    return null;
+  }
+  var len = level;
+  return rtl ? {
+    paddingRight: len * inlineIndent
+  } : {
+    paddingLeft: len * inlineIndent
+  };
+}

node_modules/rc-menu/es/hooks/useKeyRecords.d.ts

@@ -0,0 +1,10 @@
+export declare const OVERFLOW_KEY = "rc-menu-more";
+export default function useKeyRecords(): {
+    registerPath: (key: string, keyPath: string[]) => void;
+    unregisterPath: (key: string, keyPath: string[]) => void;
+    refreshOverflowKeys: (keys: string[]) => void;
+    isSubPathKey: (pathKeys: string[], eventKey: string) => boolean;
+    getKeyPath: (eventKey: string, includeOverflow?: boolean) => string[];
+    getKeys: () => string[];
+    getSubPathKeys: (key: string) => Set<string>;
+};

node_modules/rc-menu/es/hooks/useKeyRecords.js

@@ -0,0 +1,111 @@
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { useRef, useCallback } from 'react';
+import warning from "rc-util/es/warning";
+import { nextSlice } from "../utils/timeUtil";
+var PATH_SPLIT = '__RC_UTIL_PATH_SPLIT__';
+var getPathStr = function getPathStr(keyPath) {
+  return keyPath.join(PATH_SPLIT);
+};
+var getPathKeys = function getPathKeys(keyPathStr) {
+  return keyPathStr.split(PATH_SPLIT);
+};
+export var OVERFLOW_KEY = 'rc-menu-more';
+export default function useKeyRecords() {
+  var _React$useState = React.useState({}),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    internalForceUpdate = _React$useState2[1];
+  var key2pathRef = useRef(new Map());
+  var path2keyRef = useRef(new Map());
+  var _React$useState3 = React.useState([]),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    overflowKeys = _React$useState4[0],
+    setOverflowKeys = _React$useState4[1];
+  var updateRef = useRef(0);
+  var destroyRef = useRef(false);
+  var forceUpdate = function forceUpdate() {
+    if (!destroyRef.current) {
+      internalForceUpdate({});
+    }
+  };
+  var registerPath = useCallback(function (key, keyPath) {
+    // Warning for invalidate or duplicated `key`
+    if (process.env.NODE_ENV !== 'production') {
+      warning(!key2pathRef.current.has(key), "Duplicated key '".concat(key, "' used in Menu by path [").concat(keyPath.join(' > '), "]"));
+    }
+
+    // Fill map
+    var connectedPath = getPathStr(keyPath);
+    path2keyRef.current.set(connectedPath, key);
+    key2pathRef.current.set(key, connectedPath);
+    updateRef.current += 1;
+    var id = updateRef.current;
+    nextSlice(function () {
+      if (id === updateRef.current) {
+        forceUpdate();
+      }
+    });
+  }, []);
+  var unregisterPath = useCallback(function (key, keyPath) {
+    var connectedPath = getPathStr(keyPath);
+    path2keyRef.current.delete(connectedPath);
+    key2pathRef.current.delete(key);
+  }, []);
+  var refreshOverflowKeys = useCallback(function (keys) {
+    setOverflowKeys(keys);
+  }, []);
+  var getKeyPath = useCallback(function (eventKey, includeOverflow) {
+    var fullPath = key2pathRef.current.get(eventKey) || '';
+    var keys = getPathKeys(fullPath);
+    if (includeOverflow && overflowKeys.includes(keys[0])) {
+      keys.unshift(OVERFLOW_KEY);
+    }
+    return keys;
+  }, [overflowKeys]);
+  var isSubPathKey = useCallback(function (pathKeys, eventKey) {
+    return pathKeys.filter(function (item) {
+      return item !== undefined;
+    }).some(function (pathKey) {
+      var pathKeyList = getKeyPath(pathKey, true);
+      return pathKeyList.includes(eventKey);
+    });
+  }, [getKeyPath]);
+  var getKeys = function getKeys() {
+    var keys = _toConsumableArray(key2pathRef.current.keys());
+    if (overflowKeys.length) {
+      keys.push(OVERFLOW_KEY);
+    }
+    return keys;
+  };
+
+  /**
+   * Find current key related child path keys
+   */
+  var getSubPathKeys = useCallback(function (key) {
+    var connectedPath = "".concat(key2pathRef.current.get(key)).concat(PATH_SPLIT);
+    var pathKeys = new Set();
+    _toConsumableArray(path2keyRef.current.keys()).forEach(function (pathKey) {
+      if (pathKey.startsWith(connectedPath)) {
+        pathKeys.add(path2keyRef.current.get(pathKey));
+      }
+    });
+    return pathKeys;
+  }, []);
+  React.useEffect(function () {
+    return function () {
+      destroyRef.current = true;
+    };
+  }, []);
+  return {
+    // Register
+    registerPath: registerPath,
+    unregisterPath: unregisterPath,
+    refreshOverflowKeys: refreshOverflowKeys,
+    // Util
+    isSubPathKey: isSubPathKey,
+    getKeyPath: getKeyPath,
+    getKeys: getKeys,
+    getSubPathKeys: getSubPathKeys
+  };
+}

node_modules/rc-menu/es/hooks/useMemoCallback.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Cache callback function that always return same ref instead.
+ * This is used for context optimization.
+ */
+export default function useMemoCallback<T extends (...args: any[]) => void>(func: T): T;

node_modules/rc-menu/es/hooks/useMemoCallback.js

@@ -0,0 +1,18 @@
+import * as React from 'react';
+
+/**
+ * Cache callback function that always return same ref instead.
+ * This is used for context optimization.
+ */
+export default function useMemoCallback(func) {
+  var funRef = React.useRef(func);
+  funRef.current = func;
+  var callback = React.useCallback(function () {
+    var _funRef$current;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return (_funRef$current = funRef.current) === null || _funRef$current === void 0 ? void 0 : _funRef$current.call.apply(_funRef$current, [funRef].concat(args));
+  }, []);
+  return func ? callback : undefined;
+}

node_modules/rc-menu/es/hooks/useUUID.d.ts

@@ -0,0 +1 @@
+export default function useUUID(id?: string): string;

node_modules/rc-menu/es/hooks/useUUID.js

@@ -0,0 +1,19 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import useMergedState from "rc-util/es/hooks/useMergedState";
+var uniquePrefix = Math.random().toFixed(5).toString().slice(2);
+var internalId = 0;
+export default function useUUID(id) {
+  var _useMergedState = useMergedState(id, {
+      value: id
+    }),
+    _useMergedState2 = _slicedToArray(_useMergedState, 2),
+    uuid = _useMergedState2[0],
+    setUUID = _useMergedState2[1];
+  React.useEffect(function () {
+    internalId += 1;
+    var newId = process.env.NODE_ENV === 'test' ? 'test' : "".concat(uniquePrefix, "-").concat(internalId);
+    setUUID("rc-menu-uuid-".concat(newId));
+  }, []);
+  return uuid;
+}