@fecp/mobile 1.1.49 → 1.1.51

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

@@ -1,296 +0,0 @@
-"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.2.12_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, computeIsContentMenu, computeMenuOpts } = $xeTable.getComputeMaps();
-    let menuMethods = {};
-    let menuPrivateMethods = {};
-    const handleOpenMenuEvent = (evnt, type, params) => {
-      const { ctxMenuStore } = reactData;
-      const isContentMenu = computeIsContentMenu.value;
-      const menuOpts = computeMenuOpts.value;
-      const config = menuOpts[type];
-      const { transfer, visibleMethod } = menuOpts;
-      if (config) {
-        const { options, disabled } = config;
-        if (disabled) {
-          evnt.preventDefault();
-        } else if (isContentMenu && options && options.length) {
-          params.options = options;
-          $xeTable.preventEvent(evnt, "event.showMenu", params, () => {
-            if (!visibleMethod || visibleMethod(params)) {
-              evnt.preventDefault();
-              $xeTable.updateZindex();
-              const el = refElem.value;
-              const tableRect = el.getBoundingClientRect();
-              const { scrollTop, scrollLeft, visibleHeight, visibleWidth } = dom.getDomNode();
-              let top = evnt.clientY - tableRect.y;
-              let left = evnt.clientX - tableRect.x;
-              if (transfer) {
-                top = evnt.clientY + scrollTop;
-                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 $xeGrid = $xeTable.xeGrid;
-        const $xeGantt = $xeTable.xeGantt;
-        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 = { source: "table", type, $table: $xeTable, $grid: $xeGrid, $gantt: $xeGantt, 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 = { source: "table", type: layout, $table: $xeTable, $grid: $xeGrid, $gantt: $xeGantt, 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;
-        const $xeGantt = $xeTable.xeGantt;
-        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, $gantt: $xeGantt, $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);
-  },
-  setupGantt($xeGantt) {
-    return $xeGantt.extendTableMethods(tableMenuMethodKeys);
-  }
-});

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

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
-const comp = require("../../../ui/src/comp.js");
-const index = require("../../../../../../../../../_virtual/index.js");
-require("../../../ui/index.js");
-const utils = require("../../../ui/src/utils.js");
-const vn = require("../../../ui/src/vn.js");
-const index_esm = require("../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
-const { getIcon, renderEmptyElement } = index_esm.VxeUI;
-const TableMenuPanelComponent = comp.defineVxeComponent({
-  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;
-      const { transfer, destroyOnClose } = menuOpts;
-      const { visible, list, className } = ctxMenuStore;
-      return vue.h(vue.Teleport, {
-        to: "body",
-        disabled: !transfer
-      }, [
-        vue.h("div", {
-          ref: refElem,
-          class: ["vxe-table--context-menu-wrapper", className, {
-            "is--visible": visible
-          }],
-          style: ctxMenuStore.style
-        }, (destroyOnClose ? visible : true) ? list.map((options, gIndex) => {
-          return options.every((item) => item.visible === false) ? renderEmptyElement($xeTable) : vue.h("ul", {
-            class: "vxe-context-menu--option-wrapper",
-            key: gIndex
-          }, options.map((item, index$1) => {
-            const hasChildMenus = item.children && item.children.some((child) => child.visible !== false);
-            const prefixOpts = Object.assign({}, item.prefixConfig);
-            const prefixIcon = prefixOpts.icon || item.prefixIcon;
-            const suffixOpts = Object.assign({}, item.suffixConfig);
-            const suffixIcon = suffixOpts.icon || item.suffixIcon;
-            const menuContent = utils.getFuncText(item.name);
-            return item.visible === false ? renderEmptyElement($xeTable) : vue.h("li", {
-              class: [item.className, {
-                "link--disabled": item.disabled,
-                "link--active": item === ctxMenuStore.selected
-              }],
-              key: `${gIndex}_${index$1}`
-            }, [
-              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 || ""]
-                }, [
-                  prefixIcon && index.default.isFunction(prefixIcon) ? vue.h("span", {}, vn.getSlotVNs(prefixIcon({}))) : vue.h("i", {
-                    class: prefixIcon
-                  }),
-                  prefixOpts.content ? vue.h("span", {}, `${prefixOpts.content}`) : renderEmptyElement($xeTable)
-                ]),
-                vue.h("div", {
-                  class: "vxe-context-menu--link-content",
-                  title: menuContent
-                }, menuContent),
-                vue.h("div", {
-                  class: ["vxe-context-menu--link-suffix", suffixOpts.className || ""]
-                }, [
-                  suffixIcon && index.default.isFunction(suffixIcon) ? vue.h("span", {}, vn.getSlotVNs(suffixIcon({}))) : vue.h("i", {
-                    class: suffixIcon || (hasChildMenus ? getIcon().TABLE_MENU_OPTIONS : "")
-                  }),
-                  suffixOpts.content ? vue.h("span", `${suffixOpts.content}`) : renderEmptyElement($xeTable)
-                ])
-              ]),
-              hasChildMenus && item.children ? 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 childPrefixIcon = childPrefixOpts.icon || child.prefixIcon;
-                const childSuffixOpts = Object.assign({}, child.suffixConfig);
-                const childSuffixIcon = childSuffixOpts.icon || child.suffixIcon;
-                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}_${index$1}_${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 || ""]
-                    }, [
-                      childPrefixIcon && index.default.isFunction(childPrefixIcon) ? vue.h("span", {}, vn.getSlotVNs(childPrefixIcon({}))) : vue.h("i", {
-                        class: childPrefixIcon
-                      }),
-                      childPrefixOpts.content ? vue.h("span", `${childPrefixOpts.content}`) : renderEmptyElement($xeTable)
-                    ]),
-                    vue.h("div", {
-                      class: "vxe-context-menu--link-content",
-                      title: childMenuContent
-                    }, childMenuContent),
-                    vue.h("div", {
-                      class: ["vxe-context-menu--link-suffix", childSuffixOpts.className || ""]
-                    }, [
-                      childSuffixIcon && index.default.isFunction(childSuffixIcon) ? vue.h("span", {}, vn.getSlotVNs(childSuffixIcon({}))) : vue.h("i", {
-                        class: childSuffixIcon
-                      }),
-                      childSuffixOpts.content ? vue.h("span", `${childSuffixOpts.content}`) : renderEmptyElement($xeTable)
-                    ])
-                  ])
-                ]);
-              })) : null
-            ]);
-          }));
-        }) : [])
-      ]);
-    };
-    $xeMenuPanel.renderVN = renderVN;
-    return $xeMenuPanel;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
-exports.default = TableMenuPanelComponent;