@doist/reactist 29.1.1 → 29.1.2

package/lib/menu/menu.js

@@ -2,7 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var reactCompilerRuntime = require('react-compiler-runtime');
 var React = require('react');
 var react = require('@ariakit/react');
 var classNames = require('classnames');
@@ -27,92 +30,342 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
+var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
+var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var classNames__default = /*#__PURE__*/_interopDefaultLegacy(classNames);
 
-var MenuContext = React__namespace.createContext({
-    menuStore: null,
-    handleItemSelect: function () { return undefined; },
-    getAnchorRect: null,
-    setAnchorRect: function () { return undefined; },
+const _excluded = ["children", "onItemSelect"],
+  _excluded2 = ["exceptionallySetClassName"],
+  _excluded3 = ["render"],
+  _excluded4 = ["exceptionallySetClassName", "modal", "flip"],
+  _excluded5 = ["value", "children", "onSelect", "hideOnSelect", "onClick", "exceptionallySetClassName"],
+  _excluded6 = ["label", "children", "exceptionallySetClassName"];
+const MenuContext = /*#__PURE__*/React__namespace.createContext({
+  menuStore: null,
+  handleItemSelect: () => undefined,
+  getAnchorRect: null,
+  setAnchorRect: () => undefined
 });
-var SubMenuContext = React__namespace.createContext({ isSubMenu: false });
+const SubMenuContext = /*#__PURE__*/React__namespace.createContext({
+  isSubMenu: false
+});
+
+//
+// Menu
+//
+
 /**
  * Wrapper component to control a menu. It does not render anything, only providing the state
  * management for the menu components inside it.
  */
-function Menu(_a) {
-    var children = _a.children, onItemSelect = _a.onItemSelect, props = tslib.__rest(_a, ["children", "onItemSelect"]);
-    var _b = React__namespace.useState(null), anchorRect = _b[0], setAnchorRect = _b[1];
-    var getAnchorRect = React__namespace.useMemo(function () { return (anchorRect ? function () { return anchorRect; } : null); }, [anchorRect]);
-    var menuStore = react.useMenuStore(tslib.__assign({ focusLoop: true }, props));
-    var value = React__namespace.useMemo(function () { return ({ menuStore: menuStore, handleItemSelect: onItemSelect, getAnchorRect: getAnchorRect, setAnchorRect: setAnchorRect }); }, [menuStore, onItemSelect, getAnchorRect, setAnchorRect]);
-    return React__namespace.createElement(MenuContext.Provider, { value: value }, children);
+function Menu(t0) {
+  const $ = reactCompilerRuntime.c(15);
+  let children;
+  let onItemSelect;
+  let props;
+  if ($[0] !== t0) {
+    var _t = t0;
+    ({
+      children,
+      onItemSelect
+    } = _t);
+    props = _objectWithoutProperties__default["default"](_t, _excluded);
+    $[0] = t0;
+    $[1] = children;
+    $[2] = onItemSelect;
+    $[3] = props;
+  } else {
+    children = $[1];
+    onItemSelect = $[2];
+    props = $[3];
+  }
+  const [anchorRect, setAnchorRect] = React__namespace.useState(null);
+  let t1;
+  if ($[4] !== anchorRect) {
+    t1 = anchorRect ? () => anchorRect : null;
+    $[4] = anchorRect;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  const getAnchorRect = t1;
+  let t2;
+  if ($[6] !== props) {
+    t2 = _objectSpread__default["default"]({
+      focusLoop: true
+    }, props);
+    $[6] = props;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const menuStore = react.useMenuStore(t2);
+  let t3;
+  if ($[8] !== getAnchorRect || $[9] !== menuStore || $[10] !== onItemSelect) {
+    t3 = {
+      menuStore,
+      handleItemSelect: onItemSelect,
+      getAnchorRect,
+      setAnchorRect
+    };
+    $[8] = getAnchorRect;
+    $[9] = menuStore;
+    $[10] = onItemSelect;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  const value = t3;
+  let t4;
+  if ($[12] !== children || $[13] !== value) {
+    t4 = /*#__PURE__*/React__namespace.createElement(MenuContext.Provider, {
+      value: value
+    }, children);
+    $[12] = children;
+    $[13] = value;
+    $[14] = t4;
+  } else {
+    t4 = $[14];
+  }
+  return t4;
 }
+
+//
+// MenuButton
+//
+
 /**
  * A button to toggle a dropdown menu open or closed.
  */
-var MenuButton = React__namespace.forwardRef(function MenuButton(_a, ref) {
-    var exceptionallySetClassName = _a.exceptionallySetClassName, props = tslib.__rest(_a, ["exceptionallySetClassName"]);
-    var menuStore = React__namespace.useContext(MenuContext).menuStore;
-    if (!menuStore) {
-        throw new Error('MenuButton must be wrapped in <Menu/>');
-    }
-    return (React__namespace.createElement(react.MenuButton, tslib.__assign({}, props, { store: menuStore, ref: ref, className: classNames__default["default"]('reactist_menubutton', exceptionallySetClassName) })));
+const MenuButton = /*#__PURE__*/React__namespace.forwardRef(function MenuButton(t0, ref) {
+  const $ = reactCompilerRuntime.c(10);
+  let exceptionallySetClassName;
+  let props;
+  if ($[0] !== t0) {
+    var _t2 = t0;
+    ({
+      exceptionallySetClassName
+    } = _t2);
+    props = _objectWithoutProperties__default["default"](_t2, _excluded2);
+    $[0] = t0;
+    $[1] = exceptionallySetClassName;
+    $[2] = props;
+  } else {
+    exceptionallySetClassName = $[1];
+    props = $[2];
+  }
+  const {
+    menuStore
+  } = React__namespace.useContext(MenuContext);
+  if (!menuStore) {
+    throw new Error("MenuButton must be wrapped in <Menu/>");
+  }
+  let t1;
+  if ($[3] !== exceptionallySetClassName) {
+    t1 = classNames__default["default"]("reactist_menubutton", exceptionallySetClassName);
+    $[3] = exceptionallySetClassName;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== menuStore || $[6] !== props || $[7] !== ref || $[8] !== t1) {
+    t2 = /*#__PURE__*/React__namespace.createElement(react.MenuButton, _extends__default["default"]({}, props, {
+      store: menuStore,
+      ref: ref,
+      className: t1
+    }));
+    $[5] = menuStore;
+    $[6] = props;
+    $[7] = ref;
+    $[8] = t1;
+    $[9] = t2;
+  } else {
+    t2 = $[9];
+  }
+  return t2;
 });
-var ContextMenuTrigger = React__namespace.forwardRef(function ContextMenuTrigger(_a, ref) {
-    var render = _a.render, props = tslib.__rest(_a, ["render"]);
-    var _b = React__namespace.useContext(MenuContext), setAnchorRect = _b.setAnchorRect, menuStore = _b.menuStore;
-    if (!menuStore) {
-        throw new Error('ContextMenuTrigger must be wrapped in <Menu/>');
-    }
-    var handleContextMenu = React__namespace.useCallback(function handleContextMenu(event) {
-        event.preventDefault();
-        setAnchorRect({ x: event.clientX, y: event.clientY });
-        menuStore.show();
-    }, [setAnchorRect, menuStore]);
-    var isOpen = menuStore.useState('open');
-    React__namespace.useEffect(function () {
-        if (!isOpen)
-            setAnchorRect(null);
-    }, [isOpen, setAnchorRect]);
-    return React__namespace.createElement(react.Role.div, tslib.__assign({}, props, { onContextMenu: handleContextMenu, ref: ref, render: render }));
+
+//
+// ContextMenuTrigger
+//
+
+const ContextMenuTrigger = /*#__PURE__*/React__namespace.forwardRef(function ContextMenuTrigger(_ref, ref) {
+  let {
+      render
+    } = _ref,
+    props = _objectWithoutProperties__default["default"](_ref, _excluded3);
+  const {
+    setAnchorRect,
+    menuStore
+  } = React__namespace.useContext(MenuContext);
+  if (!menuStore) {
+    throw new Error('ContextMenuTrigger must be wrapped in <Menu/>');
+  }
+  const handleContextMenu = React__namespace.useCallback(function handleContextMenu(event) {
+    event.preventDefault();
+    setAnchorRect({
+      x: event.clientX,
+      y: event.clientY
+    });
+    menuStore.show();
+  }, [setAnchorRect, menuStore]);
+  const isOpen = menuStore.useState('open');
+  React__namespace.useEffect(() => {
+    if (!isOpen) setAnchorRect(null);
+  }, [isOpen, setAnchorRect]);
+  return /*#__PURE__*/React__namespace.createElement(react.Role.div, _extends__default["default"]({}, props, {
+    onContextMenu: handleContextMenu,
+    ref: ref,
+    render: render
+  }));
 });
+
+//
+// MenuList
+//
+
 /**
  * The dropdown menu itself, containing a list of menu items.
  */
-var MenuList = React__namespace.forwardRef(function MenuList(_a, ref) {
-    var exceptionallySetClassName = _a.exceptionallySetClassName, _b = _a.modal, modal = _b === void 0 ? true : _b, flip = _a.flip, props = tslib.__rest(_a, ["exceptionallySetClassName", "modal", "flip"]);
-    var _c = React__namespace.useContext(MenuContext), menuStore = _c.menuStore, getAnchorRect = _c.getAnchorRect;
-    if (!menuStore) {
-        throw new Error('MenuList must be wrapped in <Menu/>');
-    }
-    var isSubMenu = React__namespace.useContext(SubMenuContext).isSubMenu;
-    var isOpen = menuStore.useState('open');
-    return isOpen ? (React__namespace.createElement(react.Portal, { preserveTabOrder: true },
-        React__namespace.createElement(react.Menu, tslib.__assign({}, props, { store: menuStore, gutter: 8, shift: 4, ref: ref, className: classNames__default["default"]('reactist_menulist', exceptionallySetClassName), getAnchorRect: getAnchorRect !== null && getAnchorRect !== void 0 ? getAnchorRect : undefined, modal: modal, flip: flip !== null && flip !== void 0 ? flip : (isSubMenu ? 'left bottom' : undefined) })))) : null;
+const MenuList = /*#__PURE__*/React__namespace.forwardRef(function MenuList(_ref2, ref) {
+  let {
+      exceptionallySetClassName,
+      modal = true,
+      flip
+    } = _ref2,
+    props = _objectWithoutProperties__default["default"](_ref2, _excluded4);
+  const {
+    menuStore,
+    getAnchorRect
+  } = React__namespace.useContext(MenuContext);
+  if (!menuStore) {
+    throw new Error('MenuList must be wrapped in <Menu/>');
+  }
+  const {
+    isSubMenu
+  } = React__namespace.useContext(SubMenuContext);
+  const isOpen = menuStore.useState('open');
+  return isOpen ? /*#__PURE__*/React__namespace.createElement(react.Portal, {
+    preserveTabOrder: true
+  }, /*#__PURE__*/React__namespace.createElement(react.Menu, _extends__default["default"]({}, props, {
+    store: menuStore,
+    gutter: 8,
+    shift: 4,
+    ref: ref,
+    className: classNames__default["default"]('reactist_menulist', exceptionallySetClassName),
+    getAnchorRect: getAnchorRect ?? undefined,
+    modal: modal,
+    flip: flip ?? (isSubMenu ? 'left bottom' : undefined)
+  }))) : null;
 });
+
+//
+// MenuItem
+//
+
 /**
  * A menu item inside a menu list. It can be selected by the user, triggering the `onSelect`
  * callback.
  */
-var MenuItem = React__namespace.forwardRef(function MenuItem(_a, ref) {
-    var value = _a.value, children = _a.children, onSelect = _a.onSelect, _b = _a.hideOnSelect, hideOnSelect = _b === void 0 ? true : _b, onClick = _a.onClick, exceptionallySetClassName = _a.exceptionallySetClassName, props = tslib.__rest(_a, ["value", "children", "onSelect", "hideOnSelect", "onClick", "exceptionallySetClassName"]);
-    var _c = React__namespace.useContext(MenuContext), handleItemSelect = _c.handleItemSelect, menuStore = _c.menuStore;
-    if (!menuStore) {
-        throw new Error('MenuItem must be wrapped in <Menu/>');
-    }
-    var hide = menuStore.hide;
-    var handleClick = React__namespace.useCallback(function handleClick(event) {
-        onClick === null || onClick === void 0 ? void 0 : onClick(event);
-        var onSelectResult = onSelect && !event.defaultPrevented ? onSelect() : undefined;
-        var shouldClose = onSelectResult !== false && hideOnSelect;
-        handleItemSelect === null || handleItemSelect === void 0 ? void 0 : handleItemSelect(value);
-        if (shouldClose)
-            hide();
-    }, [onSelect, onClick, handleItemSelect, hideOnSelect, hide, value]);
-    return (React__namespace.createElement(react.MenuItem, tslib.__assign({}, props, { store: menuStore, ref: ref, onClick: handleClick, className: exceptionallySetClassName, hideOnClick: false }), children));
+const MenuItem = /*#__PURE__*/React__namespace.forwardRef(function MenuItem(t0, ref) {
+  const $ = reactCompilerRuntime.c(22);
+  let children;
+  let exceptionallySetClassName;
+  let onClick;
+  let onSelect;
+  let props;
+  let t1;
+  let value;
+  if ($[0] !== t0) {
+    var _t3 = t0;
+    ({
+      value,
+      children,
+      onSelect,
+      hideOnSelect: t1,
+      onClick,
+      exceptionallySetClassName
+    } = _t3);
+    props = _objectWithoutProperties__default["default"](_t3, _excluded5);
+    $[0] = t0;
+    $[1] = children;
+    $[2] = exceptionallySetClassName;
+    $[3] = onClick;
+    $[4] = onSelect;
+    $[5] = props;
+    $[6] = t1;
+    $[7] = value;
+  } else {
+    children = $[1];
+    exceptionallySetClassName = $[2];
+    onClick = $[3];
+    onSelect = $[4];
+    props = $[5];
+    t1 = $[6];
+    value = $[7];
+  }
+  const hideOnSelect = t1 === undefined ? true : t1;
+  const {
+    handleItemSelect,
+    menuStore
+  } = React__namespace.useContext(MenuContext);
+  if (!menuStore) {
+    throw new Error("MenuItem must be wrapped in <Menu/>");
+  }
+  const {
+    hide
+  } = menuStore;
+  let t2;
+  if ($[8] !== handleItemSelect || $[9] !== hide || $[10] !== hideOnSelect || $[11] !== onClick || $[12] !== onSelect || $[13] !== value) {
+    t2 = function handleClick(event) {
+      onClick?.(event);
+      const onSelectResult = onSelect && !event.defaultPrevented ? onSelect() : undefined;
+      const shouldClose = onSelectResult !== false && hideOnSelect;
+      handleItemSelect?.(value);
+      if (shouldClose) {
+        hide();
+      }
+    };
+    $[8] = handleItemSelect;
+    $[9] = hide;
+    $[10] = hideOnSelect;
+    $[11] = onClick;
+    $[12] = onSelect;
+    $[13] = value;
+    $[14] = t2;
+  } else {
+    t2 = $[14];
+  }
+  const handleClick = t2;
+  let t3;
+  if ($[15] !== children || $[16] !== exceptionallySetClassName || $[17] !== handleClick || $[18] !== menuStore || $[19] !== props || $[20] !== ref) {
+    t3 = /*#__PURE__*/React__namespace.createElement(react.MenuItem, _extends__default["default"]({}, props, {
+      store: menuStore,
+      ref: ref,
+      onClick: handleClick,
+      className: exceptionallySetClassName,
+      hideOnClick: false
+    }), children);
+    $[15] = children;
+    $[16] = exceptionallySetClassName;
+    $[17] = handleClick;
+    $[18] = menuStore;
+    $[19] = props;
+    $[20] = ref;
+    $[21] = t3;
+  } else {
+    t3 = $[21];
+  }
+  return t3;
 });
+
+//
+// SubMenu
+//
+
 /**
  * This component can be rendered alongside other `MenuItem` inside a `MenuList` in order to have
  * a sub-menu.
@@ -134,40 +387,167 @@ var MenuItem = React__namespace.forwardRef(function MenuItem(_a, ref) {
  * The `MenuButton` will become a menu item in the current menu items list, and it will lead to
  * opening a sub-menu with the menu items list below it.
  */
-var SubMenu = React__namespace.forwardRef(function SubMenu(_a, ref) {
-    var children = _a.children, onItemSelect = _a.onItemSelect;
-    var _b = React__namespace.useContext(MenuContext), parentMenuItemSelect = _b.handleItemSelect, menuStore = _b.menuStore;
-    if (!menuStore) {
-        throw new Error('SubMenu must be wrapped in <Menu/>');
-    }
-    var parentMenuHide = menuStore.hide;
-    var handleSubItemSelect = React__namespace.useCallback(function handleSubItemSelect(value) {
-        onItemSelect === null || onItemSelect === void 0 ? void 0 : onItemSelect(value);
-        parentMenuItemSelect === null || parentMenuItemSelect === void 0 ? void 0 : parentMenuItemSelect(value);
-        parentMenuHide();
-    }, [parentMenuHide, parentMenuItemSelect, onItemSelect]);
-    var _c = React__namespace.Children.toArray(children), button = _c[0], list = _c[1];
-    var buttonElement = button;
-    var subMenuContextValue = React__namespace.useMemo(function () { return ({ isSubMenu: true }); }, []);
-    return (React__namespace.createElement(Menu, { onItemSelect: handleSubItemSelect },
-        React__namespace.createElement(react.MenuItem, { store: menuStore, ref: ref, hideOnClick: false, render: buttonElement }, buttonElement.props.children),
-        React__namespace.createElement(SubMenuContext.Provider, { value: subMenuContextValue }, list)));
+const SubMenu = /*#__PURE__*/React__namespace.forwardRef(function SubMenu(t0, ref) {
+  const $ = reactCompilerRuntime.c(17);
+  const {
+    children,
+    onItemSelect
+  } = t0;
+  const {
+    handleItemSelect: parentMenuItemSelect,
+    menuStore
+  } = React__namespace.useContext(MenuContext);
+  if (!menuStore) {
+    throw new Error("SubMenu must be wrapped in <Menu/>");
+  }
+  const {
+    hide: parentMenuHide
+  } = menuStore;
+  let t1;
+  if ($[0] !== onItemSelect || $[1] !== parentMenuHide || $[2] !== parentMenuItemSelect) {
+    t1 = function handleSubItemSelect(value) {
+      onItemSelect?.(value);
+      parentMenuItemSelect?.(value);
+      parentMenuHide();
+    };
+    $[0] = onItemSelect;
+    $[1] = parentMenuHide;
+    $[2] = parentMenuItemSelect;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const handleSubItemSelect = t1;
+  let t2;
+  if ($[4] !== children) {
+    t2 = React__namespace.Children.toArray(children);
+    $[4] = children;
+    $[5] = t2;
+  } else {
+    t2 = $[5];
+  }
+  const [button, list] = t2;
+  const buttonElement = button;
+  let t3;
+  if ($[6] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = {
+      isSubMenu: true
+    };
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  const subMenuContextValue = t3;
+  let t4;
+  if ($[7] !== buttonElement || $[8] !== menuStore || $[9] !== ref) {
+    t4 = /*#__PURE__*/React__namespace.createElement(react.MenuItem, {
+      store: menuStore,
+      ref: ref,
+      hideOnClick: false,
+      render: buttonElement
+    }, buttonElement.props.children);
+    $[7] = buttonElement;
+    $[8] = menuStore;
+    $[9] = ref;
+    $[10] = t4;
+  } else {
+    t4 = $[10];
+  }
+  let t5;
+  if ($[11] !== list) {
+    t5 = /*#__PURE__*/React__namespace.createElement(SubMenuContext.Provider, {
+      value: subMenuContextValue
+    }, list);
+    $[11] = list;
+    $[12] = t5;
+  } else {
+    t5 = $[12];
+  }
+  let t6;
+  if ($[13] !== handleSubItemSelect || $[14] !== t4 || $[15] !== t5) {
+    t6 = /*#__PURE__*/React__namespace.createElement(Menu, {
+      onItemSelect: handleSubItemSelect
+    }, t4, t5);
+    $[13] = handleSubItemSelect;
+    $[14] = t4;
+    $[15] = t5;
+    $[16] = t6;
+  } else {
+    t6 = $[16];
+  }
+  return t6;
 });
+
+//
+// MenuGroup
+//
+
 /**
  * A way to semantically group some menu items.
  *
  * This group does not add any visual separator. You can do that yourself adding `<hr />` elements
  * before and/or after the group if you so wish.
  */
-var MenuGroup = React__namespace.forwardRef(function MenuGroup(_a, ref) {
-    var label = _a.label, children = _a.children, exceptionallySetClassName = _a.exceptionallySetClassName, props = tslib.__rest(_a, ["label", "children", "exceptionallySetClassName"]);
-    var menuStore = React__namespace.useContext(MenuContext).menuStore;
-    if (!menuStore) {
-        throw new Error('MenuGroup must be wrapped in <Menu/>');
-    }
-    return (React__namespace.createElement(react.MenuGroup, tslib.__assign({}, props, { ref: ref, store: menuStore, className: exceptionallySetClassName }),
-        label ? (React__namespace.createElement("div", { role: "presentation", className: "reactist_menugroup__label" }, label)) : null,
-        children));
+const MenuGroup = /*#__PURE__*/React__namespace.forwardRef(function MenuGroup(t0, ref) {
+  const $ = reactCompilerRuntime.c(14);
+  let children;
+  let exceptionallySetClassName;
+  let label;
+  let props;
+  if ($[0] !== t0) {
+    var _t4 = t0;
+    ({
+      label,
+      children,
+      exceptionallySetClassName
+    } = _t4);
+    props = _objectWithoutProperties__default["default"](_t4, _excluded6);
+    $[0] = t0;
+    $[1] = children;
+    $[2] = exceptionallySetClassName;
+    $[3] = label;
+    $[4] = props;
+  } else {
+    children = $[1];
+    exceptionallySetClassName = $[2];
+    label = $[3];
+    props = $[4];
+  }
+  const {
+    menuStore
+  } = React__namespace.useContext(MenuContext);
+  if (!menuStore) {
+    throw new Error("MenuGroup must be wrapped in <Menu/>");
+  }
+  let t1;
+  if ($[5] !== label) {
+    t1 = label ? /*#__PURE__*/React__namespace.createElement("div", {
+      role: "presentation",
+      className: "reactist_menugroup__label"
+    }, label) : null;
+    $[5] = label;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  let t2;
+  if ($[7] !== children || $[8] !== exceptionallySetClassName || $[9] !== menuStore || $[10] !== props || $[11] !== ref || $[12] !== t1) {
+    t2 = /*#__PURE__*/React__namespace.createElement(react.MenuGroup, _extends__default["default"]({}, props, {
+      ref: ref,
+      store: menuStore,
+      className: exceptionallySetClassName
+    }), t1, children);
+    $[7] = children;
+    $[8] = exceptionallySetClassName;
+    $[9] = menuStore;
+    $[10] = props;
+    $[11] = ref;
+    $[12] = t1;
+    $[13] = t2;
+  } else {
+    t2 = $[13];
+  }
+  return t2;
 });
 
 exports.ContextMenuTrigger = ContextMenuTrigger;