@fecp/mobile 1.1.22 → 1.1.24

package/lib/node_modules/.pnpm/vxe-table@4.13.27_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/menu/hook.js

@@ -0,0 +1,284 @@
+"use strict";
+const vue = require("vue");
+const index = require("../../../../../../../../../_virtual/index.js");
+require("../../../ui/index.js");
+const dom = require("../../../ui/src/dom.js");
+const utils = require("../../../ui/src/utils.js");
+const index_esm = require("../../../../../../../@vxe-ui_core@4.1.3_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { menus, hooks, globalEvents, GLOBAL_EVENT_KEYS } = index_esm.VxeUI;
+const tableMenuMethodKeys = ["closeMenu"];
+hooks.add("tableMenuModule", {
+  setupTable($xeTable) {
+    const { xID, props, reactData, internalData } = $xeTable;
+    const { refElem, refTableFilter, refTableMenu } = $xeTable.getRefMaps();
+    const { computeMouseOpts, computeIsMenu, computeMenuOpts } = $xeTable.getComputeMaps();
+    let menuMethods = {};
+    let menuPrivateMethods = {};
+    const handleOpenMenuEvent = (evnt, type, params) => {
+      const { ctxMenuStore } = reactData;
+      const isMenu = computeIsMenu.value;
+      const menuOpts = computeMenuOpts.value;
+      const config = menuOpts[type];
+      const visibleMethod = menuOpts.visibleMethod;
+      if (config) {
+        const { options, disabled } = config;
+        if (disabled) {
+          evnt.preventDefault();
+        } else if (isMenu && options && options.length) {
+          params.options = options;
+          $xeTable.preventEvent(evnt, "event.showMenu", params, () => {
+            if (!visibleMethod || visibleMethod(params)) {
+              evnt.preventDefault();
+              $xeTable.updateZindex();
+              const { scrollTop, scrollLeft, visibleHeight, visibleWidth } = dom.getDomNode();
+              let top = evnt.clientY + scrollTop;
+              let left = evnt.clientX + scrollLeft;
+              const handleVisible = () => {
+                internalData._currMenuParams = params;
+                Object.assign(ctxMenuStore, {
+                  visible: true,
+                  list: options,
+                  selected: null,
+                  selectChild: null,
+                  showChild: false,
+                  style: {
+                    zIndex: internalData.tZindex,
+                    top: `${top}px`,
+                    left: `${left}px`
+                  }
+                });
+                vue.nextTick(() => {
+                  const tableMenu = refTableMenu.value;
+                  const ctxElem = tableMenu.getRefMaps().refElem.value;
+                  const clientHeight = ctxElem.clientHeight;
+                  const clientWidth = ctxElem.clientWidth;
+                  const { boundingTop, boundingLeft } = dom.getAbsolutePos(ctxElem);
+                  const offsetTop = boundingTop + clientHeight - visibleHeight;
+                  const offsetLeft = boundingLeft + clientWidth - visibleWidth;
+                  if (offsetTop > -10) {
+                    ctxMenuStore.style.top = `${Math.max(scrollTop + 2, top - clientHeight - 2)}px`;
+                  }
+                  if (offsetLeft > -10) {
+                    ctxMenuStore.style.left = `${Math.max(scrollLeft + 2, left - clientWidth - 2)}px`;
+                  }
+                });
+              };
+              const { keyboard, row, column } = params;
+              if (keyboard && row && column) {
+                $xeTable.scrollToRow(row, column).then(() => {
+                  const cell = $xeTable.getCellElement(row, column);
+                  if (cell) {
+                    const { boundingTop, boundingLeft } = dom.getAbsolutePos(cell);
+                    top = boundingTop + scrollTop + Math.floor(cell.offsetHeight / 2);
+                    left = boundingLeft + scrollLeft + Math.floor(cell.offsetWidth / 2);
+                  }
+                  handleVisible();
+                });
+              } else {
+                handleVisible();
+              }
+            } else {
+              menuMethods.closeMenu();
+            }
+          });
+        }
+      }
+      $xeTable.closeFilter();
+    };
+    menuMethods = {
+      /**
+       * 关闭快捷菜单
+       */
+      closeMenu() {
+        Object.assign(reactData.ctxMenuStore, {
+          visible: false,
+          selected: null,
+          selectChild: null,
+          showChild: false
+        });
+        return vue.nextTick();
+      }
+    };
+    menuPrivateMethods = {
+      /**
+       * 处理菜单的移动
+       */
+      moveCtxMenu(evnt, ctxMenuStore, property, hasOper, operRest, menuList) {
+        let selectItem;
+        const selectIndex = index.default.findIndexOf(menuList, (item) => ctxMenuStore[property] === item);
+        if (hasOper) {
+          if (operRest && utils.hasChildrenList(ctxMenuStore.selected)) {
+            ctxMenuStore.showChild = true;
+          } else {
+            ctxMenuStore.showChild = false;
+            ctxMenuStore.selectChild = null;
+          }
+        } else if (globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_UP)) {
+          for (let len = selectIndex - 1; len >= 0; len--) {
+            if (menuList[len].visible !== false) {
+              selectItem = menuList[len];
+              break;
+            }
+          }
+          ctxMenuStore[property] = selectItem || menuList[menuList.length - 1];
+        } else if (globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ARROW_DOWN)) {
+          for (let index2 = selectIndex + 1; index2 < menuList.length; index2++) {
+            if (menuList[index2].visible !== false) {
+              selectItem = menuList[index2];
+              break;
+            }
+          }
+          ctxMenuStore[property] = selectItem || menuList[0];
+        } else if (ctxMenuStore[property] && (globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ENTER) || globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.SPACEBAR))) {
+          $xeTable.ctxMenuLinkEvent(evnt, ctxMenuStore[property]);
+        }
+      },
+      handleOpenMenuEvent,
+      /**
+       * 快捷菜单事件处理
+       */
+      handleGlobalContextmenuEvent(evnt) {
+        const { mouseConfig, menuConfig } = props;
+        const { editStore, ctxMenuStore } = reactData;
+        const { visibleColumn } = internalData;
+        const tableFilter = refTableFilter.value;
+        const tableMenu = refTableMenu.value;
+        const mouseOpts = computeMouseOpts.value;
+        const menuOpts = computeMenuOpts.value;
+        const el = refElem.value;
+        const { selected } = editStore;
+        const layoutList = ["header", "body", "footer"];
+        if (utils.isEnableConf(menuConfig)) {
+          if (ctxMenuStore.visible && tableMenu && dom.getEventTargetNode(evnt, tableMenu.getRefMaps().refElem.value).flag) {
+            evnt.preventDefault();
+            return;
+          }
+          if (internalData._keyCtx) {
+            const type = "body";
+            const params = { type, $table: $xeTable, keyboard: true, columns: visibleColumn.slice(0), $event: evnt };
+            if (mouseConfig && mouseOpts.area) {
+              const activeArea = $xeTable.getActiveCellArea();
+              if (activeArea && activeArea.row && activeArea.column) {
+                params.row = activeArea.row;
+                params.column = activeArea.column;
+                handleOpenMenuEvent(evnt, type, params);
+                return;
+              }
+            } else if (mouseConfig && mouseOpts.selected) {
+              if (selected.row && selected.column) {
+                params.row = selected.row;
+                params.column = selected.column;
+                handleOpenMenuEvent(evnt, type, params);
+                return;
+              }
+            }
+          }
+          for (let index2 = 0; index2 < layoutList.length; index2++) {
+            const layout = layoutList[index2];
+            const columnTargetNode = dom.getEventTargetNode(evnt, el, `vxe-${layout}--column`, (target) => {
+              return target.parentNode.parentNode.parentNode.getAttribute("xid") === xID;
+            });
+            const params = { type: layout, $table: $xeTable, columns: visibleColumn.slice(0), $event: evnt };
+            if (columnTargetNode.flag) {
+              const cell = columnTargetNode.targetElem;
+              const columnNodeRest = $xeTable.getColumnNode(cell);
+              const column = columnNodeRest ? columnNodeRest.item : null;
+              let typePrefix = `${layout}-`;
+              if (column) {
+                Object.assign(params, { column, columnIndex: $xeTable.getColumnIndex(column), cell });
+              }
+              if (layout === "body") {
+                const rowNodeRest = $xeTable.getRowNode(cell.parentNode);
+                const row = rowNodeRest ? rowNodeRest.item : null;
+                typePrefix = "";
+                if (row) {
+                  params.row = row;
+                  params.rowIndex = $xeTable.getRowIndex(row);
+                }
+              }
+              const eventType = `${typePrefix}cell-menu`;
+              handleOpenMenuEvent(evnt, layout, params);
+              $xeTable.dispatchEvent(eventType, params, evnt);
+              return;
+            } else if (dom.getEventTargetNode(evnt, el, `vxe-table--${layout}-wrapper`, (target) => target.getAttribute("xid") === xID).flag) {
+              if (menuOpts.trigger === "cell") {
+                evnt.preventDefault();
+              } else {
+                handleOpenMenuEvent(evnt, layout, params);
+              }
+              return;
+            }
+          }
+        }
+        if (tableFilter && !dom.getEventTargetNode(evnt, tableFilter.getRefMaps().refElem.value).flag) {
+          $xeTable.closeFilter();
+        }
+        menuMethods.closeMenu();
+      },
+      ctxMenuMouseoverEvent(evnt, item, child) {
+        const menuElem = evnt.currentTarget;
+        const { ctxMenuStore } = reactData;
+        evnt.preventDefault();
+        evnt.stopPropagation();
+        ctxMenuStore.selected = item;
+        ctxMenuStore.selectChild = child;
+        if (!child) {
+          ctxMenuStore.showChild = utils.hasChildrenList(item);
+          if (ctxMenuStore.showChild) {
+            vue.nextTick(() => {
+              const childWrapperElem = menuElem.nextElementSibling;
+              if (childWrapperElem) {
+                const { boundingTop, boundingLeft, visibleHeight, visibleWidth } = dom.getAbsolutePos(menuElem);
+                const posTop = boundingTop + menuElem.offsetHeight;
+                const posLeft = boundingLeft + menuElem.offsetWidth;
+                let left = "";
+                let right = "";
+                if (posLeft + childWrapperElem.offsetWidth > visibleWidth - 10) {
+                  left = "auto";
+                  right = `${menuElem.offsetWidth}px`;
+                }
+                let top = "";
+                let bottom = "";
+                if (posTop + childWrapperElem.offsetHeight > visibleHeight - 10) {
+                  top = "auto";
+                  bottom = "0";
+                }
+                childWrapperElem.style.left = left;
+                childWrapperElem.style.right = right;
+                childWrapperElem.style.top = top;
+                childWrapperElem.style.bottom = bottom;
+              }
+            });
+          }
+        }
+      },
+      ctxMenuMouseoutEvent(evnt, item) {
+        const { ctxMenuStore } = reactData;
+        if (!item.children) {
+          ctxMenuStore.selected = null;
+        }
+        ctxMenuStore.selectChild = null;
+      },
+      /**
+       * 快捷菜单点击事件
+       */
+      ctxMenuLinkEvent(evnt, menu) {
+        const $xeGrid = $xeTable.xeGrid;
+        if (!menu.disabled && (menu.code || !menu.children || !menu.children.length)) {
+          const gMenuOpts = menus.get(menu.code);
+          const params = Object.assign({}, internalData._currMenuParams, { menu, $table: $xeTable, $grid: $xeGrid, $event: evnt });
+          const tmMethod = gMenuOpts ? gMenuOpts.tableMenuMethod || gMenuOpts.menuMethod : null;
+          if (tmMethod) {
+            tmMethod(params, evnt);
+          }
+          $xeTable.dispatchEvent("menu-click", params, evnt);
+          menuMethods.closeMenu();
+        }
+      }
+    };
+    return Object.assign(Object.assign({}, menuMethods), menuPrivateMethods);
+  },
+  setupGrid($xeGrid) {
+    return $xeGrid.extendTableMethods(tableMenuMethodKeys);
+  }
+});

package/lib/node_modules/.pnpm/vxe-table@4.13.27_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/menu/panel.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+require("../../../ui/index.js");
+const utils = require("../../../ui/src/utils.js");
+const index = require("../../../../../../../../../_virtual/index.js");
+const index_esm = require("../../../../../../../@vxe-ui_core@4.1.3_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { getIcon } = index_esm.VxeUI;
+const TableMenuPanelComponent = vue.defineComponent({
+  name: "VxeTableMenuPanel",
+  setup(props, context) {
+    const xID = index.default.uniqueId();
+    const $xeTable = vue.inject("$xeTable", {});
+    const { reactData: tableReactData } = $xeTable;
+    const refElem = vue.ref();
+    const refMaps = {
+      refElem
+    };
+    const $xeMenuPanel = {
+      xID,
+      props,
+      context,
+      getRefMaps: () => refMaps
+    };
+    const renderVN = () => {
+      const { ctxMenuStore } = tableReactData;
+      const { computeMenuOpts } = $xeTable.getComputeMaps();
+      const menuOpts = computeMenuOpts.value;
+      return vue.h(vue.Teleport, {
+        to: "body",
+        disabled: false
+      }, [
+        vue.h("div", {
+          ref: refElem,
+          class: ["vxe-table--context-menu-wrapper", menuOpts.className, {
+            "is--visible": ctxMenuStore.visible
+          }],
+          style: ctxMenuStore.style
+        }, ctxMenuStore.list.map((options, gIndex) => {
+          return options.every((item) => item.visible === false) ? vue.createCommentVNode() : vue.h("ul", {
+            class: "vxe-context-menu--option-wrapper",
+            key: gIndex
+          }, options.map((item, index2) => {
+            const hasChildMenus = item.children && item.children.some((child) => child.visible !== false);
+            const prefixOpts = Object.assign({}, item.prefixConfig);
+            const suffixOpts = Object.assign({}, item.suffixConfig);
+            const menuContent = utils.getFuncText(item.name);
+            return item.visible === false ? null : vue.h("li", {
+              class: [item.className, {
+                "link--disabled": item.disabled,
+                "link--active": item === ctxMenuStore.selected
+              }],
+              key: `${gIndex}_${index2}`
+            }, [
+              vue.h("a", {
+                class: "vxe-context-menu--link",
+                onClick(evnt) {
+                  $xeTable.ctxMenuLinkEvent(evnt, item);
+                },
+                onMouseover(evnt) {
+                  $xeTable.ctxMenuMouseoverEvent(evnt, item);
+                },
+                onMouseout(evnt) {
+                  $xeTable.ctxMenuMouseoutEvent(evnt, item);
+                }
+              }, [
+                vue.h("div", {
+                  class: ["vxe-context-menu--link-prefix", prefixOpts.className || ""]
+                }, [
+                  vue.h("i", {
+                    class: prefixOpts.icon || item.prefixIcon
+                  }),
+                  prefixOpts.content ? vue.h("span", {}, `${prefixOpts.content}`) : vue.createCommentVNode()
+                ]),
+                vue.h("div", {
+                  class: "vxe-context-menu--link-content",
+                  title: menuContent
+                }, menuContent),
+                vue.h("div", {
+                  class: ["vxe-context-menu--link-suffix", suffixOpts.className || ""]
+                }, [
+                  vue.h("i", {
+                    class: suffixOpts.icon || item.suffixIcon || (hasChildMenus ? getIcon().TABLE_MENU_OPTIONS : "")
+                  }),
+                  suffixOpts.content ? vue.h("span", `${suffixOpts.content}`) : vue.createCommentVNode()
+                ])
+              ]),
+              hasChildMenus ? vue.h("ul", {
+                class: ["vxe-table--context-menu-clild-wrapper", {
+                  "is--show": item === ctxMenuStore.selected && ctxMenuStore.showChild
+                }]
+              }, item.children.map((child, cIndex) => {
+                const childPrefixOpts = Object.assign({}, child.prefixConfig);
+                const childSuffixOpts = Object.assign({}, child.suffixConfig);
+                const childMenuContent = utils.getFuncText(child.name);
+                return child.visible === false ? null : vue.h("li", {
+                  class: [child.className, {
+                    "link--disabled": child.disabled,
+                    "link--active": child === ctxMenuStore.selectChild
+                  }],
+                  key: `${gIndex}_${index2}_${cIndex}`
+                }, [
+                  vue.h("a", {
+                    class: "vxe-context-menu--link",
+                    onClick(evnt) {
+                      $xeTable.ctxMenuLinkEvent(evnt, child);
+                    },
+                    onMouseover(evnt) {
+                      $xeTable.ctxMenuMouseoverEvent(evnt, item, child);
+                    },
+                    onMouseout(evnt) {
+                      $xeTable.ctxMenuMouseoutEvent(evnt, item);
+                    }
+                  }, [
+                    vue.h("div", {
+                      class: ["vxe-context-menu--link-prefix", childPrefixOpts.className || ""]
+                    }, [
+                      vue.h("i", {
+                        class: childPrefixOpts.icon || child.prefixIcon
+                      }),
+                      childPrefixOpts.content ? vue.h("span", `${childPrefixOpts.content}`) : vue.createCommentVNode()
+                    ]),
+                    vue.h("div", {
+                      class: "vxe-context-menu--link-content",
+                      title: childMenuContent
+                    }, childMenuContent),
+                    vue.h("div", {
+                      class: ["vxe-context-menu--link-suffix", childSuffixOpts.className || ""]
+                    }, [
+                      vue.h("i", {
+                        class: childSuffixOpts.icon
+                      }),
+                      childSuffixOpts.content ? vue.h("span", `${childSuffixOpts.content}`) : vue.createCommentVNode()
+                    ])
+                  ])
+                ]);
+              })) : null
+            ]);
+          }));
+        }))
+      ]);
+    };
+    $xeMenuPanel.renderVN = renderVN;
+    return $xeMenuPanel;
+  },
+  render() {
+    return this.renderVN();
+  }
+});
+exports.default = TableMenuPanelComponent;