@weitutech/by-components 1.1.220 → 1.2.0

package/lib/by-components.common.js

@@ -74276,6 +74276,7 @@ __webpack_require__.d(__webpack_exports__, {
   ByCardSelector: function() { return /* reexport */ ByCardSelector; },
   ByCardView: function() { return /* reexport */ ByCardView; },
   ByCascaderPanel: function() { return /* reexport */ ByCascaderPanel; },
+  ByCascaderPanelPro: function() { return /* reexport */ ByCascaderPanelPro; },
   ByCommonInput: function() { return /* reexport */ ByCommonInput; },
   ByCommonSelector: function() { return /* reexport */ ByCommonSelector; },
   ByCustomDatePicker: function() { return /* reexport */ custom_date_picker; },
@@ -96014,6 +96015,3198 @@ var ByCascaderPanel_component = normalizeComponent(
 )
 
 /* harmony default export */ var ByCascaderPanel = (ByCascaderPanel_component.exports);
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"8cd600e8-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/cascader-panel-pro/ByCascaderPanelPro.vue?vue&type=template&id=4bdb9820
+var ByCascaderPanelProvue_type_template_id_4bdb9820_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    staticClass: "cascader-panel-pro"
+  }, [_c('div', {
+    staticClass: "panel-container"
+  }, [_c('div', {
+    staticClass: "left-panel"
+  }, [_c('div', {
+    staticClass: "panel-header"
+  }, [!_vm.aggregationMode ? _c('div', {
+    staticClass: "panel-title"
+  }, [_vm._v("可选(" + _vm._s(_vm.selectedCount) + "/" + _vm._s(_vm.totalCount) + ")")]) : _vm._e(), _c('div', {
+    staticClass: "search-section"
+  }, [_c('div', {
+    staticClass: "search-container"
+  }, [_c('el-input', {
+    staticClass: "search-input",
+    attrs: {
+      "placeholder": _vm.searchPlaceholder,
+      "clearable": "",
+      "size": "mini",
+      "disabled": _vm.isViewMode
+    },
+    model: {
+      value: _vm.searchInput,
+      callback: function ($$v) {
+        _vm.searchInput = $$v;
+      },
+      expression: "searchInput"
+    }
+  }), _vm.isMultiple && !_vm.isViewMode ? _c('el-popover', {
+    attrs: {
+      "placement": "bottom-start",
+      "width": 300,
+      "trigger": "click",
+      "popper-class": "batch-search-popover-pro"
+    },
+    on: {
+      "show": _vm.handleBatchSearchShow
+    },
+    model: {
+      value: _vm.batchSearchVisible,
+      callback: function ($$v) {
+        _vm.batchSearchVisible = $$v;
+      },
+      expression: "batchSearchVisible"
+    }
+  }, [_c('div', {
+    staticClass: "batch-search-container"
+  }, [_c('div', {
+    staticClass: "popover-title"
+  }, [_vm._v("批量输入")]), _c('el-input', {
+    staticClass: "batch-search-textarea",
+    attrs: {
+      "type": "textarea",
+      "rows": 12,
+      "placeholder": "请输入名称，多个名称用换行、逗号、分号、空格分隔"
+    },
+    model: {
+      value: _vm.batchSearchContent,
+      callback: function ($$v) {
+        _vm.batchSearchContent = $$v;
+      },
+      expression: "batchSearchContent"
+    }
+  }), _c('div', {
+    staticClass: "popover-footer"
+  }, [_c('el-button', {
+    attrs: {
+      "size": "mini"
+    },
+    on: {
+      "click": function ($event) {
+        _vm.batchSearchVisible = false;
+      }
+    }
+  }, [_vm._v("取消")]), _c('el-button', {
+    attrs: {
+      "size": "mini",
+      "type": "primary"
+    },
+    on: {
+      "click": _vm.handleBatchSearch
+    }
+  }, [_vm._v("确定")])], 1)], 1), _c('el-button', {
+    staticClass: "batch-search-btn",
+    attrs: {
+      "slot": "reference",
+      "size": "mini",
+      "type": "text"
+    },
+    slot: "reference"
+  }, [_c('i', {
+    staticClass: "el-icon-edit-outline"
+  })])], 1) : _vm._e()], 1)]), _c('div', {
+    staticClass: "action-buttons"
+  }, [_vm.searchInput === '' && _vm.isMultiple && _vm.showSelectAll && !_vm.isViewMode ? _c('div', {
+    staticClass: "all-select",
+    on: {
+      "click": _vm.handleSelectAll
+    }
+  }, [_vm._v(" " + _vm._s(_vm.isAllSelected ? '取消全选' : '全选') + " ")]) : _vm._e()])]), _c('div', {
+    staticClass: "panel-content",
+    style: {
+      height: _vm.computedPanelHeight + 'px'
+    }
+  }, [_c('div', {
+    staticClass: "cascader-content-wrapper",
+    style: {
+      height: '100%'
+    }
+  }, [_vm.isShow && _vm.filteredOptions.length > 0 ? _c('VirtualCascaderPanel', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.searchInput === '' || !_vm.isShowSearch,
+      expression: "searchInput === '' || !isShowSearch"
+    }],
+    ref: "cascaderPanel",
+    staticClass: "cascader-panel-inner",
+    style: {
+      height: _vm.computedPanelHeight - 20 + 'px'
+    },
+    attrs: {
+      "value": _vm.panelPresentationValue,
+      "sync-value-from-parent": !_vm.useCompactSelection,
+      "options": _vm.filteredOptions,
+      "props": _vm.cascaderProps,
+      "height": _vm.computedPanelHeight - 20,
+      "column-min-width": _vm.columnMinWidth,
+      "column-max-width": _vm.columnMaxWidth,
+      "disabled-config": _vm.disabledConfig,
+      "is-view-mode": _vm.isViewMode
+    },
+    on: {
+      "input": _vm.onMainPanelInput,
+      "change": _vm.handleValueChange
+    }
+  }) : _vm._e(), _vm.searchOptions.length > 0 ? _c('VirtualCascaderPanel', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.searchInput !== '' && _vm.isShowSearch,
+      expression: "searchInput !== '' && isShowSearch"
+    }],
+    ref: "searchCascaderPanel",
+    staticClass: "cascader-panel-inner",
+    attrs: {
+      "value": _vm.compactSearchPanelValue,
+      "sync-value-from-parent": false,
+      "options": _vm.searchOptions,
+      "props": _vm.cascaderProps,
+      "height": _vm.computedPanelHeight - 20,
+      "column-min-width": _vm.columnMinWidth,
+      "column-max-width": _vm.columnMaxWidth,
+      "disabled-config": _vm.disabledConfig,
+      "is-view-mode": _vm.isViewMode
+    },
+    on: {
+      "input": _vm.onSearchPanelInput,
+      "change": _vm.handleSearchValueChange
+    }
+  }) : _vm._e(), _vm.isShowSearch && _vm.searchOptions.length === 0 ? _c('div', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.searchInput !== '',
+      expression: "searchInput !== ''"
+    }],
+    staticClass: "empty-search"
+  }, [_c('el-empty', {
+    attrs: {
+      "image-size": 100
+    }
+  })], 1) : _vm._e()], 1)])]), _c('div', {
+    staticClass: "right-panel"
+  }, [_c('div', {
+    staticClass: "panel-header"
+  }, [_c('div', {
+    staticClass: "panel-title"
+  }, [_vm._v("已选(" + _vm._s(_vm.selectedItems.length) + ")")]), _c('div', {
+    staticClass: "action-buttons"
+  }, [_vm.selectedItems.length > 0 && !_vm.isViewMode ? _c('div', {
+    staticClass: "clear-btn",
+    on: {
+      "click": _vm.clearSelection
+    }
+  }, [_vm._v("清除")]) : _vm._e()])]), _c('div', {
+    staticClass: "panel-content",
+    style: {
+      height: _vm.computedPanelHeight - 5 + 'px'
+    }
+  }, [_c('div', {
+    staticClass: "selected-list"
+  }, [_vm.selectedItems.length > 0 ? _c('VcpVirtualList', {
+    staticClass: "selected-virtual-list",
+    style: {
+      height: _vm.selectedListHeight + 'px'
+    },
+    attrs: {
+      "items": _vm.selectedItems,
+      "item-height": _vm.selectedItemHeight,
+      "height": _vm.selectedListHeight,
+      "list-padding": 0,
+      "overscan": 10
+    },
+    scopedSlots: _vm._u([{
+      key: "default",
+      fn: function ({
+        item,
+        index
+      }) {
+        return [_c('div', {
+          key: 'selected-' + item.value + '-' + index,
+          staticClass: "selected-item-row"
+        }, [_c('div', {
+          staticClass: "selected-item"
+        }, [_c('div', {
+          staticClass: "item-content"
+        }, [_c('div', {
+          staticClass: "item-label"
+        }, [_vm._v(_vm._s(item.label || ''))]), _vm.showSubtitle && _vm.subtitleField && item[_vm.subtitleField] ? _c('div', {
+          staticClass: "item-subtitle"
+        }, [_vm._v(" " + _vm._s(item[_vm.subtitleField]) + " ")]) : _vm._e()]), !_vm.isViewMode ? _c('div', {
+          staticClass: "remove-btn",
+          on: {
+            "click": function ($event) {
+              return _vm.removeItem(item, index);
+            }
+          }
+        }, [_c('i', {
+          staticClass: "el-icon-close"
+        })]) : _vm._e()])])];
+      }
+    }], null, false, 2638469921)
+  }) : _c('div', {
+    staticClass: "empty-state"
+  }, [_vm._v("暂无选中项")])], 1)])])])]);
+};
+var ByCascaderPanelProvue_type_template_id_4bdb9820_staticRenderFns = [];
+
+;// ./src/components/cascader-panel-pro/cascaderUtilsPro.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 级联选择器工具类（Pro 版，独立于 CascaderUtils）
+ */
+class CascaderUtilsPro {
+  /**
+   * 估算级联节点标签文本宽度（px）
+   */
+  static measureCascaderLabelWidth(label, fontSize = 14) {
+    if (!label) {
+      return 0;
+    }
+    const str = String(label);
+    let width = 0;
+    for (let i = 0; i < str.length; i++) {
+      const code = str.charCodeAt(i);
+      width += code > 255 ? fontSize : Math.ceil(fontSize * 0.55);
+    }
+    return width;
+  }
+
+  /**
+   * 根据列内最长标签计算列宽
+   */
+  static getCascaderColumnWidth(nodes, options = {}) {
+    const {
+      minWidth = 180,
+      maxWidth = 420,
+      extraPadding = 56,
+      hasCheckbox = true
+    } = options;
+    if (!nodes || nodes.length === 0) {
+      return minWidth;
+    }
+    let maxLabelWidth = 0;
+    nodes.forEach(node => {
+      maxLabelWidth = Math.max(maxLabelWidth, this.measureCascaderLabelWidth(node.label));
+    });
+    const checkboxWidth = hasCheckbox ? 28 : 0;
+    const arrowWidth = 24;
+    const contentWidth = maxLabelWidth + extraPadding + checkboxWidth + arrowWidth;
+    return Math.min(maxWidth, Math.max(minWidth, Math.ceil(contentWidth)));
+  }
+
+  /**
+   * 判断项目是否禁用
+   * @param {Object} item - 项目数据
+   * @param {Object} config - 禁用配置
+   * @param {String} config.disabledField - 禁用字段名
+   * @param {*} config.disabledValue - 禁用值
+   * @param {Function} config.disabledCheck - 自定义禁用判断函数
+   * @returns {Boolean} 是否禁用
+   */
+  static isItemDisabled(item, config) {
+    const {
+      disabledField,
+      disabledValue,
+      disabledCheck
+    } = config;
+
+    // 优先使用自定义禁用判断函数
+    if (disabledCheck && typeof disabledCheck === 'function') {
+      return disabledCheck(item);
+    }
+
+    // 检查直接的 disabled 属性
+    if (item.disabled === true) {
+      return true;
+    }
+
+    // 使用字段判断
+    const fieldValue = item[disabledField];
+    if (fieldValue !== undefined) {
+      return fieldValue === disabledValue;
+    }
+    return false;
+  }
+
+  /**
+   * 检查路径上是否存在禁选项
+   * @param {Array} tree - 树形数据
+   * @param {Array} path - 路径数组
+   * @param {Object} config - 禁用配置
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Boolean} 路径上是否存在禁选项
+   */
+  static isPathDisabled(tree, path, config, cascaderProps) {
+    if (!path || path.length === 0) return false;
+    const findPathInTree = (nodes, targetPath, currentIndex = 0) => {
+      if (currentIndex >= targetPath.length) return false;
+      for (const node of nodes) {
+        if (node[cascaderProps.value] === targetPath[currentIndex]) {
+          // 检查当前节点是否禁用
+          if (this.isItemDisabled(node, config)) {
+            return true;
+          }
+
+          // 如果还有下一级，继续检查
+          if (currentIndex < targetPath.length - 1 && node[cascaderProps.children]) {
+            return findPathInTree(node[cascaderProps.children], targetPath, currentIndex + 1);
+          }
+
+          // 如果已经到达路径末尾，返回false（路径上没有禁选项）
+          return false;
+        }
+      }
+      return false;
+    };
+    return findPathInTree(tree, path);
+  }
+
+  /**
+   * 设置禁用项
+   * @param {Array} options - 选项数据
+   * @param {Object} config - 禁用配置
+   * @param {Object} cascaderProps - 级联配置
+   */
+  static setDisabledItems(options, config, cascaderProps) {
+    const processItems = items => {
+      items.forEach(item => {
+        // 判断是否禁用
+        if (this.isItemDisabled(item, config)) {
+          item.disabled = true;
+        }
+        // 递归处理子项
+        if (item[cascaderProps.children]) {
+          processItems(item[cascaderProps.children]);
+        }
+      });
+    };
+    processItems(options);
+  }
+
+  /**
+   * 统计总项目数（排除禁用项和路径上有禁选项的项）
+   * @param {Array} options - 选项数据
+   * @param {Object} config - 禁用配置
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Number} 总项目数
+   */
+  static countTotalItems(options, config, cascaderProps) {
+    let totalCount = 0;
+    const countItems = (items, currentPath = []) => {
+      items.forEach(item => {
+        const newPath = [...currentPath, item[cascaderProps.value]];
+
+        // 检查当前节点是否禁用
+        const isCurrentDisabled = this.isItemDisabled(item, config);
+        if (!item[cascaderProps.children]) {
+          // 只统计非禁用项且路径上没有禁选项的叶子节点
+          if (!isCurrentDisabled && !this.isPathDisabled(options, newPath, config, cascaderProps)) {
+            totalCount++;
+          }
+        } else {
+          // 如果当前节点禁用，则其所有子节点都不可选
+          if (!isCurrentDisabled) {
+            countItems(item[cascaderProps.children], newPath);
+          }
+        }
+      });
+    };
+    countItems(options);
+    return totalCount;
+  }
+
+  /**
+   * 在树形数据中搜索
+   * @param {Array} tree - 树形数据
+   * @param {String} keyword - 搜索关键词
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 搜索结果
+   */
+  static searchInTree(tree, keyword, cascaderProps) {
+    const result = [];
+    const labelKey = cascaderProps.label || 'label';
+    const childrenKey = cascaderProps.children || 'children';
+    tree.forEach(node => {
+      const label = node[labelKey];
+      if (label && label.includes(keyword)) {
+        result.push({
+          ...node
+        });
+      } else if (node[childrenKey]) {
+        const matchedChildren = this.searchInTree(node[childrenKey], keyword, cascaderProps);
+        if (matchedChildren.length > 0) {
+          result.push({
+            ...node,
+            [childrenKey]: matchedChildren
+          });
+        }
+      }
+    });
+    return result;
+  }
+
+  /**
+   * 基于扁平 store 快速搜索（父节点命中时直接复用 raw 子树，跳过子级遍历）
+   */
+  static searchFromStore(store, keyword, cascaderProps) {
+    if (!store || !keyword) {
+      return [];
+    }
+    const childrenKey = cascaderProps.children || 'children';
+    const walk = parentId => {
+      const childIds = parentId == null ? store.rootIds : store.childrenByParentId.get(parentId) || [];
+      const result = [];
+      for (let i = 0; i < childIds.length; i++) {
+        const node = store.nodeById.get(childIds[i]);
+        if (!node) {
+          continue;
+        }
+        const label = node.label || '';
+        if (label.includes(keyword)) {
+          result.push({
+            ...node.raw
+          });
+        } else if (!node.isLeaf) {
+          const matchedChildren = walk(node.id);
+          if (matchedChildren.length > 0) {
+            result.push({
+              ...node.raw,
+              [childrenKey]: matchedChildren
+            });
+          }
+        }
+      }
+      return result;
+    };
+    return walk(null);
+  }
+
+  /**
+   * 获取叶子节点的值
+   * @param {Array} tree - 树形数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 叶子节点值数组
+   */
+  static getLeafValues(tree, cascaderProps) {
+    const leafValues = [];
+    const traverse = nodes => {
+      nodes.forEach(node => {
+        if (!node[cascaderProps.children]) {
+          leafValues.push(node[cascaderProps.value]);
+        } else {
+          traverse(node[cascaderProps.children]);
+        }
+      });
+    };
+    traverse(tree);
+    return leafValues;
+  }
+
+  /**
+   * 获取所有叶子节点的路径（排除禁用项和路径上有禁选项的项）
+   * @param {Array} tree - 树形数据
+   * @param {Object} config - 禁用配置
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 路径数组
+   */
+  static getAllLeafPaths(tree, config, cascaderProps) {
+    const paths = [];
+    const traverse = (nodes, currentPath = []) => {
+      nodes.forEach(node => {
+        const newPath = [...currentPath, node[cascaderProps.value]];
+
+        // 检查当前节点是否禁用
+        const isCurrentDisabled = this.isItemDisabled(node, config);
+        if (!node[cascaderProps.children]) {
+          // 只包含非禁用项且路径上没有禁选项的叶子节点
+          if (!isCurrentDisabled && !this.isPathDisabled(tree, newPath, config, cascaderProps)) {
+            paths.push(newPath);
+          }
+        } else {
+          // 如果当前节点禁用，则其所有子节点都不可选
+          if (!isCurrentDisabled) {
+            traverse(node[cascaderProps.children], newPath);
+          }
+        }
+      });
+    };
+    traverse(tree);
+    return paths;
+  }
+
+  /**
+   * 根据路径查找节点
+   * @param {Array} tree - 树形数据
+   * @param {Array} path - 路径数组
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Object|null} 找到的节点
+   */
+  static findNodeByPath(tree, path, cascaderProps) {
+    if (!path || path.length === 0) return null;
+    const findInTree = (nodes, targetPath) => {
+      for (const node of nodes) {
+        if (node[cascaderProps.value] == targetPath[0]) {
+          if (targetPath.length === 1) {
+            return node;
+          } else if (node[cascaderProps.children]) {
+            return findInTree(node[cascaderProps.children], targetPath.slice(1));
+          }
+        }
+      }
+      return null;
+    };
+    return findInTree(tree, path);
+  }
+
+  /**
+   * 基于 selectedValues 构建已选项列表
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 已选项列表
+   */
+  static buildSelectedItemsFromValues(selectedValues, options, cascaderProps) {
+    const items = [];
+    selectedValues.forEach(path => {
+      if (path.length > 0) {
+        const leafValue = path[path.length - 1];
+        // 从原始数据中查找对应的节点信息
+        const node = this.findNodeByPath(options, path, cascaderProps);
+        if (node) {
+          // 包含完整的节点数据，以便访问额外的字段（如子标题字段）
+          items.push({
+            ...node,
+            // 展开所有原始节点数据
+            value: leafValue,
+            label: node[cascaderProps.label],
+            path: path
+          });
+        }
+      }
+    });
+    return items;
+  }
+
+  /**
+   * 从自研面板 selection 直接构建已选项（紧凑模式，避免生成万级路径数组）
+   */
+  static buildSelectedItemsFromSelection(store, selection, options, cascaderProps) {
+    if (!store || !selection) {
+      return [];
+    }
+    const items = [];
+    selection.selectedLeafSet.forEach(leafValue => {
+      const path = store.pathByLeafValue.get(leafValue);
+      const node = store.nodeByValue.get(leafValue);
+      if (!path || !node) {
+        return;
+      }
+      items.push({
+        ...node.raw,
+        value: leafValue,
+        label: node.label,
+        path
+      });
+    });
+    return items;
+  }
+
+  /**
+   * 获取搜索范围内的选中值
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Array} searchOptions - 搜索结果
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 搜索范围内的选中值
+   */
+  static getSearchSelectedValues(selectedValues, searchOptions, cascaderProps) {
+    const searchLeafValues = this.getLeafValues(searchOptions, cascaderProps);
+    return selectedValues.filter(path => {
+      const leafValue = path[path.length - 1];
+      return searchLeafValues.includes(leafValue);
+    });
+  }
+
+  /**
+   * 检查父项的所有子项是否都被选中
+   * @param {Object} parentNode - 父节点
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Boolean} 是否所有子项都被选中
+   */
+  static isParentFullySelected(parentNode, selectedValues, cascaderProps) {
+    if (!parentNode[cascaderProps.children]) {
+      return false;
+    }
+
+    // 获取父项的所有叶子节点
+    const allLeafValues = this.getLeafValues([parentNode], cascaderProps);
+
+    // 检查所有叶子节点是否都在选中值中
+    return allLeafValues.every(leafValue => {
+      return selectedValues.some(path => {
+        const pathLeafValue = path[path.length - 1];
+        return pathLeafValue === leafValue;
+      });
+    });
+  }
+
+  /**
+   * 根据路径获取对应的标签数组
+   * @param {Array} path - 节点路径
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 标签数组
+   */
+  static getPathLabels(path, options, cascaderProps) {
+    const labels = [];
+    let currentNodes = options;
+    for (let i = 0; i < path.length; i++) {
+      const targetValue = path[i];
+      const foundNode = currentNodes.find(node => node[cascaderProps.value] === targetValue);
+      if (foundNode) {
+        labels.push(foundNode[cascaderProps.label]);
+        if (foundNode[cascaderProps.children] && i < path.length - 1) {
+          currentNodes = foundNode[cascaderProps.children];
+        }
+      } else {
+        labels.push(targetValue); // 如果找不到对应的节点，使用原始值
+      }
+    }
+    return labels;
+  }
+
+  /**
+   * 构建完整的节点信息对象
+   * @param {Object} node - 原始节点数据
+   * @param {Array} path - 节点路径
+   * @param {Object} cascaderProps - 级联配置
+   * @param {Array} options - 选项数据
+   * @param {Boolean} isAggregated - 是否为聚合项
+   * @returns {Object} 完整的节点信息对象
+   */
+  static buildCompleteNodeInfo(node, path, cascaderProps, options, isAggregated = false) {
+    const hasChildren = !!node[cascaderProps.children];
+    const level = path.length - 1;
+    return {
+      // 展开原始节点的所有属性，以便访问额外的字段（如子标题字段）
+      ...node,
+      // 基本属性（覆盖原始节点中的同名属性）
+      value: node[cascaderProps.value],
+      label: node[cascaderProps.label],
+      path: path,
+      isAggregated: isAggregated,
+      // 节点结构信息
+      hasChildren: hasChildren,
+      level: level,
+      children: hasChildren ? node[cascaderProps.children] : undefined,
+      // 级联面板相关属性
+      checked: true,
+      indeterminate: false,
+      loaded: true,
+      loading: false,
+      // 原始数据
+      data: node,
+      // 路径相关
+      pathLabels: this.getPathLabels(path, options, cascaderProps),
+      // 其他可能需要的属性
+      config: cascaderProps,
+      parent: null,
+      // 在级联面板中会动态设置
+      pathNodes: null // 在级联面板中会动态设置
+    };
+  }
+
+  /**
+   * 从自研面板的选中状态递归构建聚合列表（与 getAggregatedSelectedItems 逻辑一致）
+   * 父节点全选时只返回父项；半选时向下展开到具体子项
+   */
+  static getAggregatedItemsFromSelection(store, selection, options, cascaderProps) {
+    if (!store || !selection) {
+      return [];
+    }
+    const items = [];
+    const walk = nodeId => {
+      const node = store.nodeById.get(nodeId);
+      if (!node || node.disabled) {
+        return;
+      }
+      const state = selection.getCheckState(nodeId);
+      if (state === 'unchecked' || state === 'disabled') {
+        return;
+      }
+      if (!node.isLeaf && state === 'checked') {
+        items.push(this.buildCompleteNodeInfo(node.raw, node.path, cascaderProps, options, true));
+        return;
+      }
+      if (node.isLeaf && state === 'checked') {
+        items.push(this.buildCompleteNodeInfo(node.raw, node.path, cascaderProps, options, false));
+        return;
+      }
+      const childIds = node.childIds || [];
+      childIds.forEach(childId => walk(childId));
+    };
+    store.rootIds.forEach(rootId => walk(rootId));
+    return items;
+  }
+
+  /** @deprecated 使用 getAggregatedItemsFromSelection */
+  static getAggregatedItemsFromRootSelection(store, selection, options, cascaderProps) {
+    return this.getAggregatedItemsFromSelection(store, selection, options, cascaderProps);
+  }
+  static getAggregatedEmitValues(items, prefix = '__parent__') {
+    return items.map(item => {
+      if (item.isAggregated) {
+        return this.addParentNodePrefix(item.value, prefix);
+      }
+      return item.value;
+    });
+  }
+
+  /**
+   * 获取聚合模式下的选中项（如果父项完全选中，则只返回父项）
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 聚合后的选中项列表
+   */
+  static getAggregatedSelectedItems(selectedValues, options, cascaderProps) {
+    const items = [];
+    const processedPaths = new Set();
+
+    // 递归检查每个节点
+    const checkNode = (nodes, currentPath = []) => {
+      nodes.forEach(node => {
+        const newPath = [...currentPath, node[cascaderProps.value]];
+        const pathKey = newPath.join(',');
+
+        // 如果这个路径已经被处理过，跳过
+        if (processedPaths.has(pathKey)) {
+          return;
+        }
+
+        // 检查当前节点是否完全选中
+        if (this.isParentFullySelected(node, selectedValues, cascaderProps)) {
+          // 父项完全选中，添加父项
+          items.push(this.buildCompleteNodeInfo(node, newPath, cascaderProps, options, true));
+
+          // 标记所有子路径为已处理
+          const allLeafValues = this.getLeafValues([node], cascaderProps);
+          selectedValues.forEach(path => {
+            const pathLeafValue = path[path.length - 1];
+            if (allLeafValues.includes(pathLeafValue)) {
+              processedPaths.add(path.join(','));
+            }
+          });
+        } else if (!node[cascaderProps.children]) {
+          // 叶子节点，检查是否在选中值中且未被父项覆盖
+          const leafValue = node[cascaderProps.value];
+          const isSelected = selectedValues.some(path => {
+            const pathLeafValue = path[path.length - 1];
+            return pathLeafValue === leafValue;
+          });
+          if (isSelected && !processedPaths.has(pathKey)) {
+            items.push(this.buildCompleteNodeInfo(node, newPath, cascaderProps, options, false));
+            processedPaths.add(pathKey);
+          }
+        } else {
+          // 继续检查子节点
+          checkNode(node[cascaderProps.children], newPath);
+        }
+      });
+    };
+    checkNode(options);
+    return items;
+  }
+
+  /**
+   * 获取聚合模式下的选中值（只返回最终选中的值，不包含被聚合的子项）
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @param {String} prefix - 前缀标识
+   * @returns {Array} 聚合后的选中值
+   */
+  static getAggregatedSelectedValues(selectedValues, options, cascaderProps, prefix = '__parent__') {
+    const aggregatedItems = this.getAggregatedSelectedItems(selectedValues, options, cascaderProps);
+    return aggregatedItems.map(item => {
+      // 如果是聚合项（非叶子节点），添加前缀标识
+      if (item.isAggregated) {
+        return this.addParentNodePrefix(item.value, prefix);
+      }
+      return item.value;
+    });
+  }
+
+  /**
+   * 获取聚合模式下的路径数组（只返回最终选中的路径，不包含被聚合的子项路径）
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 聚合后的路径数组
+   */
+  static getAggregatedSelectedPaths(selectedValues, options, cascaderProps) {
+    const aggregatedItems = this.getAggregatedSelectedItems(selectedValues, options, cascaderProps);
+    return aggregatedItems.map(item => item.path);
+  }
+
+  /**
+   * 检查聚合模式下是否全选（所有可选的叶子节点都被选中）
+   * @param {Array} selectedValues - 已选值数组
+   * @param {Array} options - 选项数据
+   * @param {Object} config - 禁用配置
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Boolean} 是否全选
+   */
+  static isAggregatedAllSelected(selectedValues, options, config, cascaderProps) {
+    // 获取所有可选的叶子节点
+    const allSelectableLeafValues = this.getAllLeafPaths(options, config, cascaderProps).map(path => path[path.length - 1]); // 获取叶子节点的值
+
+    // 获取当前选中的叶子节点值
+    const selectedLeafValues = selectedValues.map(path => path[path.length - 1]);
+
+    // 检查所有可选的叶子节点是否都被选中
+    return allSelectableLeafValues.every(leafValue => selectedLeafValues.includes(leafValue));
+  }
+
+  /**
+   * 检查值是否为非叶子节点标识
+   * @param {*} value - 要检查的值
+   * @param {String} prefix - 前缀标识
+   * @returns {Boolean} 是否为非叶子节点标识
+   */
+  static isParentNodeValue(value, prefix = '__parent__') {
+    return typeof value === 'string' && value.startsWith(prefix);
+  }
+
+  /**
+   * 从非叶子节点标识中提取实际值
+   * @param {String} parentValue - 非叶子节点标识值
+   * @param {String} prefix - 前缀标识
+   * @returns {String} 实际值
+   */
+  static extractParentNodeValue(parentValue, prefix = '__parent__') {
+    if (this.isParentNodeValue(parentValue, prefix)) {
+      return parentValue.substring(prefix.length);
+    }
+    return parentValue;
+  }
+
+  /**
+   * 为非叶子节点值添加前缀标识
+   * @param {String} value - 原始值
+   * @param {String} prefix - 前缀标识
+   * @returns {String} 带前缀的值
+   */
+  static addParentNodePrefix(value, prefix = '__parent__') {
+    return prefix + value;
+  }
+
+  /**
+   * 根据非叶子节点值获取其所有叶子节点的路径
+   * @param {String} parentValue - 非叶子节点值
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 叶子节点路径数组
+   */
+  static getLeafPathsByParentValue(parentValue, options, cascaderProps) {
+    const paths = [];
+
+    // 查找非叶子节点
+    const findParentNode = (nodes, currentPath = []) => {
+      for (const node of nodes) {
+        const newPath = [...currentPath, node[cascaderProps.value]];
+        if (node[cascaderProps.value] == parentValue) {
+          // 找到目标非叶子节点，获取其所有叶子节点路径
+          this.getAllLeafPaths([node], {}, cascaderProps).forEach(leafPath => {
+            // 将叶子节点路径与当前路径合并
+            const fullPath = [...currentPath, ...leafPath];
+            paths.push(fullPath);
+          });
+          return true;
+        }
+
+        // 递归查找子节点
+        if (node[cascaderProps.children] && node[cascaderProps.children].length > 0) {
+          if (findParentNode(node[cascaderProps.children], newPath)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    findParentNode(options);
+    return paths;
+  }
+
+  /**
+   * 处理包含非叶子节点的值数组，将非叶子节点转换为对应的叶子节点路径
+   * @param {Array} values - 值数组（可能包含非叶子节点标识）
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @param {String} prefix - 前缀标识
+   * @returns {Array} 处理后的路径数组
+   */
+  static processValuesWithParentNodes(values, options, cascaderProps, prefix = '__parent__') {
+    const paths = [];
+    for (const value of values) {
+      if (this.isParentNodeValue(value, prefix)) {
+        // 非叶子节点，获取其所有叶子节点路径
+        const actualValue = this.extractParentNodeValue(value, prefix);
+        const leafPaths = this.getLeafPathsByParentValue(actualValue, options, cascaderProps);
+        paths.push(...leafPaths);
+      } else {
+        // 普通值，查找对应的路径
+        const valuePaths = this.findPathsByValues([value], options, cascaderProps);
+        paths.push(...valuePaths);
+      }
+    }
+    return paths;
+  }
+
+  /**
+   * 根据values找到对应的路径（支持非叶子节点）
+   * @param {Array} values - 值数组
+   * @param {Array} options - 选项数据
+   * @param {Object} cascaderProps - 级联配置
+   * @returns {Array} 路径数组
+   */
+  static findPathsByValues(values, options, cascaderProps) {
+    const paths = [];
+    const findPath = (nodes, targetValues, currentPath = []) => {
+      for (const option of nodes) {
+        const newPath = [...currentPath, option[cascaderProps.value]];
+        if (targetValues.includes(option[cascaderProps.value])) {
+          // 如果是叶子节点（没有children属性），添加到路径中
+          if (!option[cascaderProps.children]) {
+            paths.push(newPath);
+          }
+        }
+
+        // 递归查找子节点
+        if (option[cascaderProps.children] && option[cascaderProps.children].length > 0) {
+          findPath(option[cascaderProps.children], targetValues, newPath);
+        }
+      }
+    };
+    findPath(options, values);
+    return paths;
+  }
+}
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"8cd600e8-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/cascader-panel-pro/VirtualCascaderPanel.vue?vue&type=template&id=23086f90
+var VirtualCascaderPanelvue_type_template_id_23086f90_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    staticClass: "el-cascader-panel vcp-panel is-bordered",
+    style: {
+      height: _vm.height + 'px'
+    }
+  }, _vm._l(_vm.columns, function (columnNodes, colIndex) {
+    return _c('div', {
+      key: 'col-' + colIndex,
+      staticClass: "el-cascader-menu vcp-menu",
+      class: {
+        'is-last': colIndex === _vm.columns.length - 1
+      },
+      style: _vm.getColumnStyle(colIndex, columnNodes)
+    }, [_c('VcpVirtualList', {
+      attrs: {
+        "items": columnNodes,
+        "item-height": _vm.itemHeight,
+        "height": _vm.height
+      },
+      scopedSlots: _vm._u([{
+        key: "default",
+        fn: function ({
+          item
+        }) {
+          return [_c('li', {
+            key: 'vcp-node-' + item.id,
+            staticClass: "el-cascader-node",
+            class: _vm.getNodeClass(item, colIndex),
+            attrs: {
+              "role": "menuitem",
+              "id": 'vcp-node-' + item.id,
+              "aria-expanded": !item.isLeaf && _vm.isExpanded(item, colIndex),
+              "tabindex": _vm.isActive(item, colIndex) ? 0 : -1
+            },
+            on: {
+              "click": function ($event) {
+                return _vm.onNodeClick(item, colIndex);
+              }
+            }
+          }, [_vm.multiple ? _c('span', {
+            staticClass: "el-cascader-node__prefix"
+          }, [_c('el-checkbox', {
+            attrs: {
+              "value": _vm.isChecked(item),
+              "indeterminate": _vm.isIndeterminate(item),
+              "disabled": item.disabled || _vm.isViewMode
+            },
+            on: {
+              "change": function ($event) {
+                return _vm.onCheckClick(item, $event);
+              }
+            },
+            nativeOn: {
+              "click": function ($event) {
+                $event.stopPropagation();
+              }
+            }
+          })], 1) : _vm.checkStrictly ? _c('span', {
+            staticClass: "el-cascader-node__prefix",
+            on: {
+              "click": function ($event) {
+                $event.stopPropagation();
+                return _vm.onRadioClick(item);
+              }
+            }
+          }, [_c('el-radio', {
+            attrs: {
+              "value": _vm.singleCheckedValue,
+              "label": item.value,
+              "disabled": item.disabled || _vm.isViewMode
+            },
+            on: {
+              "input": function ($event) {
+                return _vm.onRadioClick(item);
+              }
+            }
+          }, [_c('span')])], 1) : _vm._e(), _c('span', {
+            staticClass: "el-cascader-node__label"
+          }, [_vm._v(_vm._s(item.label))]), !item.isLeaf ? _c('span', {
+            staticClass: "el-cascader-node__postfix"
+          }, [_c('i', {
+            staticClass: "el-icon-arrow-right el-cascader-node__icon-arrow"
+          })]) : _vm._e()])];
+        }
+      }], null, true)
+    })], 1);
+  }), 0);
+};
+var VirtualCascaderPanelvue_type_template_id_23086f90_staticRenderFns = [];
+
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"8cd600e8-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/cascader-panel-pro/VirtualList.vue?vue&type=template&id=43cb1148
+var VirtualListvue_type_template_id_43cb1148_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    ref: "scroller",
+    staticClass: "vcp-virtual-scroller el-scrollbar__wrap",
+    on: {
+      "scroll": _vm.onScroll
+    }
+  }, [!_vm.enableVirtual ? _c('ul', {
+    staticClass: "el-cascader-menu__list vcp-native-list"
+  }, [_vm._l(_vm.items, function (item, index) {
+    return [_vm._t("default", null, {
+      "item": item,
+      "index": index
+    })];
+  })], 2) : [_c('div', {
+    staticClass: "vcp-virtual-phantom",
+    style: {
+      height: _vm.totalHeight + 'px'
+    }
+  }), _c('ul', {
+    staticClass: "el-cascader-menu__list vcp-virtual-list",
+    style: {
+      transform: 'translateY(' + _vm.offsetY + 'px)'
+    }
+  }, [_vm._l(_vm.visibleItems, function (item, index) {
+    return [_vm._t("default", null, {
+      "item": item,
+      "index": _vm.startIndex + index
+    })];
+  })], 2)]], 2);
+};
+var VirtualListvue_type_template_id_43cb1148_staticRenderFns = [];
+
+;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/cascader-panel-pro/VirtualList.vue?vue&type=script&lang=js
+/* harmony default export */ var VirtualListvue_type_script_lang_js = ({
+  name: 'VcpVirtualList',
+  props: {
+    items: {
+      type: Array,
+      default: () => []
+    },
+    itemHeight: {
+      type: Number,
+      default: 34
+    },
+    height: {
+      type: Number,
+      default: 200
+    },
+    overscan: {
+      type: Number,
+      default: 8
+    },
+    listPadding: {
+      type: Number,
+      default: 12
+    }
+  },
+  data() {
+    return {
+      scrollTop: 0
+    };
+  },
+  computed: {
+    totalHeight() {
+      return this.items.length * this.itemHeight + this.listPadding;
+    },
+    enableVirtual() {
+      return this.totalHeight > this.height;
+    },
+    startIndex() {
+      const index = Math.floor(this.scrollTop / this.itemHeight) - this.overscan;
+      return Math.max(0, index);
+    },
+    endIndex() {
+      const visibleCount = Math.ceil(this.height / this.itemHeight) + this.overscan * 2;
+      return Math.min(this.items.length, this.startIndex + visibleCount);
+    },
+    offsetY() {
+      return this.startIndex * this.itemHeight;
+    },
+    visibleItems() {
+      return this.items.slice(this.startIndex, this.endIndex);
+    }
+  },
+  watch: {
+    items(newItems, oldItems) {
+      if (!this.isSameItemList(newItems, oldItems)) {
+        this.resetScroll();
+      }
+    },
+    enableVirtual(newVal, oldVal) {
+      if (newVal !== oldVal) {
+        this.resetScroll();
+      }
+    }
+  },
+  methods: {
+    isSameItemList(nextItems, prevItems) {
+      if (!nextItems || !prevItems) {
+        return false;
+      }
+      if (nextItems.length !== prevItems.length) {
+        return false;
+      }
+      for (let i = 0; i < nextItems.length; i++) {
+        if (this.getItemKey(nextItems[i]) !== this.getItemKey(prevItems[i])) {
+          return false;
+        }
+      }
+      return true;
+    },
+    getItemKey(item) {
+      if (!item) {
+        return '';
+      }
+      return item.id != null ? item.id : item.value;
+    },
+    onScroll(event) {
+      this.scrollTop = event.target.scrollTop;
+    },
+    resetScroll() {
+      this.scrollTop = 0;
+      if (this.$refs.scroller) {
+        this.$refs.scroller.scrollTop = 0;
+      }
+    }
+  }
+});
+;// ./src/components/cascader-panel-pro/VirtualList.vue?vue&type=script&lang=js
+ /* harmony default export */ var cascader_panel_pro_VirtualListvue_type_script_lang_js = (VirtualListvue_type_script_lang_js); 
+;// ./src/components/cascader-panel-pro/VirtualList.vue
+
+
+
+
+
+/* normalize component */
+;
+var VirtualList_component = normalizeComponent(
+  cascader_panel_pro_VirtualListvue_type_script_lang_js,
+  VirtualListvue_type_template_id_43cb1148_render,
+  VirtualListvue_type_template_id_43cb1148_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var VirtualList = (VirtualList_component.exports);
+;// ./src/components/cascader-panel-pro/cascaderStorePro.js
+
+
+
+
+
+
+/**
+ * 级联树扁平化存储，初始化时预计算子树叶子元数据，供 O(1) 级勾选/聚合
+ */
+
+let nodeIdSeed = 0;
+function nextId() {
+  nodeIdSeed += 1;
+  return nodeIdSeed;
+}
+function resetCascaderStoreIdSeed() {
+  nodeIdSeed = 0;
+}
+
+/**
+ * @param {Array} options
+ * @param {Object} config - disabledField/disabledValue/disabledCheck
+ * @param {Object} cascaderProps
+ * @param {Object} utils - CascaderUtilsPro
+ */
+function buildCascaderStore(options, config, cascaderProps, utils) {
+  resetCascaderStoreIdSeed();
+  const valueKey = cascaderProps.value || 'value';
+  const labelKey = cascaderProps.label || 'label';
+  const childrenKey = cascaderProps.children || 'children';
+  const disabledKey = cascaderProps.disabled || 'disabled';
+  const nodes = [];
+  const nodeById = new Map();
+  const nodeByValue = new Map();
+  const childrenByParentId = new Map();
+  const rootIds = [];
+  const pathByLeafValue = new Map();
+  const allLeafValues = [];
+  const allLeafPaths = [];
+  const createNode = (raw, parentPath, level, parentId) => {
+    const value = raw[valueKey];
+    const children = raw[childrenKey];
+    const hasChildren = Array.isArray(children) && children.length > 0;
+    const id = nextId();
+    const nodePath = parentId == null ? [value] : parentPath.concat(value);
+    const node = {
+      id,
+      value,
+      label: raw[labelKey],
+      path: nodePath,
+      level,
+      parentId,
+      childIds: [],
+      isLeaf: !hasChildren,
+      disabled: !!raw[disabledKey],
+      raw,
+      descendantLeafValues: [],
+      descendantLeafCount: 0,
+      descendantPaths: []
+    };
+    nodes.push(node);
+    nodeById.set(id, node);
+    if (!nodeByValue.has(value)) {
+      nodeByValue.set(value, node);
+    }
+    if (parentId == null) {
+      rootIds.push(id);
+    } else {
+      const siblings = childrenByParentId.get(parentId) || [];
+      siblings.push(id);
+      childrenByParentId.set(parentId, siblings);
+      const parent = nodeById.get(parentId);
+      if (parent) {
+        parent.childIds.push(id);
+      }
+    }
+    if (hasChildren) {
+      children.forEach(child => {
+        createNode(child, nodePath, level + 1, id);
+      });
+    } else if (!node.disabled) {
+      pathByLeafValue.set(value, nodePath);
+      allLeafValues.push(value);
+      allLeafPaths.push(nodePath);
+    }
+    return node;
+  };
+  const walkRoots = (items, ancestorDisabled = false) => {
+    items.forEach(item => {
+      const isDisabled = ancestorDisabled || utils.isItemDisabled(item, config);
+      const cloned = {
+        ...item
+      };
+      if (isDisabled) {
+        cloned[disabledKey] = true;
+      }
+      createNode(cloned, [], 0, null);
+    });
+  };
+  walkRoots(options || []);
+
+  // 自底向上汇总子树叶子
+  const sorted = nodes.slice().sort((a, b) => b.level - a.level);
+  sorted.forEach(node => {
+    if (node.isLeaf) {
+      if (!node.disabled) {
+        node.descendantLeafValues = [node.value];
+        node.descendantLeafCount = 1;
+        node.descendantPaths = [node.path];
+      }
+      return;
+    }
+    const leafValues = [];
+    const leafPaths = [];
+    node.childIds.forEach(childId => {
+      const child = nodeById.get(childId);
+      if (!child || child.descendantLeafCount === 0) {
+        return;
+      }
+      leafValues.push(...child.descendantLeafValues);
+      leafPaths.push(...child.descendantPaths);
+    });
+    node.descendantLeafValues = leafValues;
+    node.descendantLeafCount = leafValues.length;
+    node.descendantPaths = leafPaths;
+  });
+  return {
+    nodes,
+    nodeById,
+    nodeByValue,
+    childrenByParentId,
+    rootIds,
+    pathByLeafValue,
+    allLeafValues,
+    allLeafPaths,
+    totalLeafCount: allLeafPaths.length
+  };
+}
+function getStoreChildren(store, parentId) {
+  if (parentId == null) {
+    return store.rootIds.map(id => store.nodeById.get(id)).filter(Boolean);
+  }
+  const childIds = store.childrenByParentId.get(parentId) || [];
+  return childIds.map(id => store.nodeById.get(id)).filter(Boolean);
+}
+function findStoreNodeByPath(store, pathValues) {
+  if (!pathValues || pathValues.length === 0) {
+    return null;
+  }
+  let node = store.nodeByValue.get(pathValues[0]);
+  if (!node || pathValues.length === 1) {
+    return node;
+  }
+  for (let i = 1; i < pathValues.length; i++) {
+    const target = pathValues[i];
+    const children = getStoreChildren(store, node.id);
+    node = children.find(child => child.value == target) || null;
+    if (!node) {
+      return null;
+    }
+  }
+  return node;
+}
+;// ./src/components/cascader-panel-pro/selectionStatePro.js
+
+
+
+
+
+
+
+
+
+
+const COMPACT_EMIT_THRESHOLD = 300;
+
+class SelectionStatePro {
+  constructor(store) {
+    this.store = store;
+    this.selectedLeafSet = new Set();
+    this.subtreeSelectedCount = new Map();
+  }
+  clear() {
+    this.selectedLeafSet.clear();
+    this.subtreeSelectedCount.clear();
+  }
+  isEmpty() {
+    return this.selectedLeafSet.size === 0;
+  }
+  size() {
+    return this.selectedLeafSet.size;
+  }
+  _incAncestors(nodeId, delta) {
+    let current = this.store.nodeById.get(nodeId);
+    while (current) {
+      const prev = this.subtreeSelectedCount.get(current.id) || 0;
+      const next = prev + delta;
+      if (next <= 0) {
+        this.subtreeSelectedCount.delete(current.id);
+      } else {
+        this.subtreeSelectedCount.set(current.id, next);
+      }
+      if (current.parentId == null) {
+        break;
+      }
+      current = this.store.nodeById.get(current.parentId);
+    }
+  }
+
+  /**
+   * 自底向上重算 nodeId 子树内各层选中数
+   */
+  _reconcileSubtreeCounts(nodeId) {
+    const node = this.store.nodeById.get(nodeId);
+    if (!node) {
+      return 0;
+    }
+    if (node.isLeaf) {
+      return this.selectedLeafSet.has(node.value) ? 1 : 0;
+    }
+    let selected = 0;
+    node.childIds.forEach(childId => {
+      selected += this._reconcileSubtreeCounts(childId);
+    });
+    if (selected > 0) {
+      this.subtreeSelectedCount.set(nodeId, selected);
+    } else {
+      this.subtreeSelectedCount.delete(nodeId);
+    }
+    return selected;
+  }
+
+  /**
+   * 从当前节点向上汇总祖先的选中数（勾选子节点后父级需半选/全选）
+   */
+  _reconcileAncestors(nodeId) {
+    var _this$store$nodeById$;
+    let parentId = (_this$store$nodeById$ = this.store.nodeById.get(nodeId)) === null || _this$store$nodeById$ === void 0 ? void 0 : _this$store$nodeById$.parentId;
+    while (parentId != null) {
+      const parent = this.store.nodeById.get(parentId);
+      if (!parent) {
+        break;
+      }
+      let selected = 0;
+      parent.childIds.forEach(childId => {
+        const child = this.store.nodeById.get(childId);
+        if (!child) {
+          return;
+        }
+        if (child.isLeaf) {
+          if (this.selectedLeafSet.has(child.value)) {
+            selected++;
+          }
+        } else {
+          selected += this.subtreeSelectedCount.get(childId) || 0;
+        }
+      });
+      if (selected > 0) {
+        this.subtreeSelectedCount.set(parentId, selected);
+      } else {
+        this.subtreeSelectedCount.delete(parentId);
+      }
+      parentId = parent.parentId;
+    }
+  }
+  _reconcileAllRoots() {
+    this.subtreeSelectedCount.clear();
+    this.store.rootIds.forEach(rootId => {
+      this._reconcileSubtreeCounts(rootId);
+    });
+  }
+  _applyLeaf(value, checked) {
+    const has = this.selectedLeafSet.has(value);
+    if (checked && !has) {
+      this.selectedLeafSet.add(value);
+      const node = this.store.nodeByValue.get(value);
+      if (node) {
+        this._incAncestors(node.id, 1);
+      }
+    } else if (!checked && has) {
+      this.selectedLeafSet.delete(value);
+      const node = this.store.nodeByValue.get(value);
+      if (node) {
+        this._incAncestors(node.id, -1);
+      }
+    }
+  }
+  toggleNode(nodeId, checked) {
+    const node = this.store.nodeById.get(nodeId);
+    if (!node || node.disabled) {
+      return;
+    }
+    if (node.isLeaf) {
+      const had = this.selectedLeafSet.has(node.value);
+      this._applyLeaf(node.value, checked);
+      if (had !== this.selectedLeafSet.has(node.value)) {
+        this._reconcileAncestors(node.id);
+      }
+      return;
+    }
+    const leaves = node.descendantLeafValues;
+    if (leaves.length === 0) {
+      return;
+    }
+    let changedCount = 0;
+    leaves.forEach(v => {
+      const has = this.selectedLeafSet.has(v);
+      if (checked) {
+        if (!has) {
+          this.selectedLeafSet.add(v);
+          changedCount++;
+        }
+      } else if (has) {
+        this.selectedLeafSet.delete(v);
+        changedCount++;
+      }
+    });
+    if (changedCount > 0) {
+      this._reconcileSubtreeCounts(nodeId);
+      this._reconcileAncestors(nodeId);
+    }
+  }
+  selectAll() {
+    this.clear();
+    const leaves = this.store.allLeafValues;
+    leaves.forEach(v => this.selectedLeafSet.add(v));
+    this._reconcileAllRoots();
+  }
+  syncFromPaths(paths) {
+    this.clear();
+    if (!Array.isArray(paths) || paths.length === 0) {
+      return;
+    }
+    paths.forEach(path => {
+      if (!Array.isArray(path) || path.length === 0) {
+        return;
+      }
+      const leafValue = path[path.length - 1];
+      if (this.store.pathByLeafValue.has(leafValue)) {
+        this.selectedLeafSet.add(leafValue);
+      }
+    });
+    this._reconcileAllRoots();
+  }
+  getCheckState(nodeId) {
+    const node = this.store.nodeById.get(nodeId);
+    if (!node || node.disabled) {
+      return 'disabled';
+    }
+    if (node.isLeaf) {
+      return this.selectedLeafSet.has(node.value) ? 'checked' : 'unchecked';
+    }
+    const total = node.descendantLeafCount;
+    if (total === 0) {
+      return 'unchecked';
+    }
+    const selected = this.subtreeSelectedCount.get(node.id) || 0;
+    if (selected === 0) {
+      return 'unchecked';
+    }
+    if (selected >= total) {
+      return 'checked';
+    }
+    return 'indeterminate';
+  }
+  isChecked(nodeId) {
+    return this.getCheckState(nodeId) === 'checked';
+  }
+  isIndeterminate(nodeId) {
+    return this.getCheckState(nodeId) === 'indeterminate';
+  }
+  isPathInCheckedValues(path) {
+    if (!path || path.length === 0) {
+      return false;
+    }
+    const leafValue = path[path.length - 1];
+    return this.selectedLeafSet.has(leafValue);
+  }
+  isNodeInCheckedPath(node) {
+    if (!node) {
+      return false;
+    }
+    return this.isPathInCheckedValues(node.path);
+  }
+  getCheckedPaths() {
+    const paths = [];
+    this.selectedLeafSet.forEach(leafValue => {
+      const path = this.store.pathByLeafValue.get(leafValue);
+      if (path) {
+        paths.push(path);
+      }
+    });
+    return paths;
+  }
+  isCompactSelection() {
+    return this.selectedLeafSet.size >= COMPACT_EMIT_THRESHOLD;
+  }
+
+  /** 从聚合父节点值快速同步（如 __parent__province_0） */
+  syncFromParentValues(parentValues, prefix = '__parent__') {
+    this.clear();
+    if (!Array.isArray(parentValues) || parentValues.length === 0) {
+      return;
+    }
+    parentValues.forEach(val => {
+      let rootValue = val;
+      if (typeof val === 'string' && val.startsWith(prefix)) {
+        rootValue = val.substring(prefix.length);
+      }
+      const node = this.store.nodeByValue.get(rootValue);
+      if (node && !node.isLeaf && !node.disabled) {
+        node.descendantLeafValues.forEach(v => this.selectedLeafSet.add(v));
+      }
+    });
+    this._reconcileAllRoots();
+  }
+}
+;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/cascader-panel-pro/VirtualCascaderPanel.vue?vue&type=script&lang=js
+
+
+
+
+
+
+
+
+/* harmony default export */ var VirtualCascaderPanelvue_type_script_lang_js = ({
+  name: 'VirtualCascaderPanel',
+  components: {
+    VcpVirtualList: VirtualList
+  },
+  props: {
+    value: {
+      type: [Array, String, Number],
+      default: () => []
+    },
+    options: {
+      type: Array,
+      default: () => []
+    },
+    props: {
+      type: Object,
+      default: () => ({
+        multiple: true,
+        label: 'label',
+        value: 'value',
+        children: 'children',
+        checkStrictly: false
+      })
+    },
+    height: {
+      type: Number,
+      default: 280
+    },
+    columnMinWidth: {
+      type: Number,
+      default: 180
+    },
+    columnMaxWidth: {
+      type: Number,
+      default: 420
+    },
+    disabledConfig: {
+      type: Object,
+      default: () => ({})
+    },
+    isViewMode: {
+      type: Boolean,
+      default: false
+    },
+    autoExpandDeep: {
+      type: Boolean,
+      default: true
+    },
+    // 是否从 value prop 同步选中（紧凑模式下由面板内部维护选中状态）
+    syncValueFromParent: {
+      type: Boolean,
+      default: true
+    }
+  },
+  data() {
+    return {
+      store: null,
+      selection: null,
+      activePath: [],
+      itemHeight: 34,
+      syncingValue: false,
+      suppressValueSync: false,
+      selectionTick: 0
+    };
+  },
+  computed: {
+    multiple() {
+      return this.props.multiple !== false;
+    },
+    checkStrictly() {
+      return !!this.props.checkStrictly;
+    },
+    columns() {
+      if (!this.store) {
+        return [];
+      }
+      const cols = [getStoreChildren(this.store, null)];
+      this.activePath.forEach(nodeId => {
+        const node = this.store.nodeById.get(nodeId);
+        if (!node || node.isLeaf) {
+          return;
+        }
+        const children = getStoreChildren(this.store, nodeId);
+        if (children.length > 0) {
+          cols.push(children);
+        }
+      });
+      return cols;
+    },
+    singleCheckedValue() {
+      if (this.multiple || !Array.isArray(this.value) || this.value.length === 0) {
+        return null;
+      }
+      const path = Array.isArray(this.value[0]) ? this.value[0] : this.value;
+      return path[path.length - 1];
+    }
+  },
+  watch: {
+    options: {
+      handler() {
+        this.rebuildStore();
+      }
+    },
+    value: {
+      handler() {
+        if (this.suppressValueSync || !this.syncValueFromParent) {
+          return;
+        }
+        this.syncFromValue();
+      },
+      deep: false
+    },
+    activePath: {
+      handler() {
+        this.$nextTick(() => {
+          this.syncHorizontalOverflow();
+        });
+      },
+      deep: true
+    }
+  },
+  created() {
+    this.rebuildStore();
+  },
+  mounted() {
+    this._onWindowResize = () => {
+      this.syncHorizontalOverflow();
+    };
+    window.addEventListener('resize', this._onWindowResize, {
+      passive: true
+    });
+    this.syncHorizontalOverflow();
+  },
+  beforeDestroy() {
+    if (this._onWindowResize) {
+      window.removeEventListener('resize', this._onWindowResize);
+      this._onWindowResize = null;
+    }
+    if (this._hScrollRaf) {
+      cancelAnimationFrame(this._hScrollRaf);
+      this._hScrollRaf = null;
+    }
+  },
+  methods: {
+    syncHorizontalOverflow() {
+      if (this._hScrollRaf) {
+        cancelAnimationFrame(this._hScrollRaf);
+      }
+      this._hScrollRaf = requestAnimationFrame(() => {
+        this._hScrollRaf = null;
+        const panel = this.$el;
+        const wrapper = panel && panel.closest('.cascader-content-wrapper');
+        if (!panel || !wrapper) {
+          return;
+        }
+        const overflow = panel.scrollWidth - wrapper.clientWidth;
+        const hadScroll = wrapper.classList.contains('is-horizontal-scroll');
+        // 滞回区间，避免边界宽度下 overflow 来回切换
+        const needsScroll = hadScroll ? overflow > -4 : overflow > 1;
+        if (needsScroll !== hadScroll) {
+          wrapper.classList.toggle('is-horizontal-scroll', needsScroll);
+        }
+      });
+    },
+    getColumnStyle(colIndex, columnNodes) {
+      const width = CascaderUtilsPro.getCascaderColumnWidth(columnNodes, {
+        minWidth: this.columnMinWidth,
+        maxWidth: this.columnMaxWidth,
+        hasCheckbox: this.multiple || this.checkStrictly
+      });
+      return {
+        width: width + 'px',
+        minWidth: width + 'px',
+        maxWidth: width + 'px'
+      };
+    },
+    rebuildStore() {
+      this.store = buildCascaderStore(this.options, this.disabledConfig, this.props, CascaderUtilsPro);
+      this.selection = new SelectionStatePro(this.store);
+      this.activePath = [];
+      if (this.syncValueFromParent) {
+        this.syncFromValue();
+      }
+      this.$nextTick(() => {
+        this.syncHorizontalOverflow();
+      });
+    },
+    syncFromValue() {
+      if (!this.selection) {
+        return;
+      }
+      this.syncingValue = true;
+      if (this.multiple) {
+        const paths = Array.isArray(this.value) ? this.value : [];
+        this.selection.syncFromPaths(paths);
+      } else {
+        const path = this.normalizeSinglePath(this.value);
+        this.selection.syncFromPaths(path ? [path] : []);
+        if (path && path.length > 1) {
+          this.expandPathValues(path.slice(0, -1), false);
+        }
+      }
+      this.syncingValue = false;
+    },
+    normalizeSinglePath(val) {
+      if (val == null || val === '') {
+        return null;
+      }
+      if (Array.isArray(val)) {
+        if (val.length === 0) {
+          return null;
+        }
+        if (Array.isArray(val[0])) {
+          return val[0];
+        }
+        return val;
+      }
+      const node = this.store && this.store.nodeByValue.get(val);
+      if (node) {
+        return node.path;
+      }
+      return [val];
+    },
+    emitValue() {
+      if (this.syncingValue || !this.selection) {
+        return;
+      }
+      if (this.selection.isCompactSelection()) {
+        this.$emit('change', {
+          compact: true,
+          count: this.selection.size()
+        });
+        return;
+      }
+      let emitVal;
+      if (this.multiple) {
+        emitVal = this.selection.getCheckedPaths();
+      } else {
+        const paths = this.selection.getCheckedPaths();
+        emitVal = paths.length > 0 ? paths[0] : [];
+      }
+      this.$emit('input', emitVal);
+      this.$emit('change', emitVal);
+    },
+    isActive(node, colIndex) {
+      return colIndex < this.activePath.length && this.activePath[colIndex] === node.id;
+    },
+    isExpanded(node, colIndex) {
+      return this.activePath[colIndex] === node.id;
+    },
+    isInActivePath(node) {
+      return this.activePath.includes(node.id);
+    },
+    getNodeClass(node, colIndex) {
+      return {
+        'is-selectable': this.checkStrictly,
+        'is-disabled': node.disabled || this.isViewMode,
+        'in-active-path': this.isInActivePath(node),
+        'in-checked-path': this.checkStrictly && this.isInCheckedPath(node),
+        'is-active': this.isNodeActive(node)
+      };
+    },
+    isInCheckedPath(node) {
+      void this.selectionTick;
+      if (!this.selection || !this.checkStrictly) {
+        return false;
+      }
+      return this.selection.isNodeInCheckedPath(node);
+    },
+    isNodeActive(node) {
+      void this.selectionTick;
+      if (!this.selection) {
+        return false;
+      }
+      if (this.multiple) {
+        if (this.checkStrictly) {
+          return this.selection.isNodeInCheckedPath(node);
+        }
+        return node.isLeaf && this.selection.selectedLeafSet.has(node.value);
+      }
+      const paths = this.selection.getCheckedPaths();
+      if (paths.length === 0) {
+        return false;
+      }
+      const activePath = paths[0];
+      return activePath[activePath.length - 1] === node.value;
+    },
+    isChecked(node) {
+      void this.selectionTick;
+      return this.selection ? this.selection.isChecked(node.id) : false;
+    },
+    isIndeterminate(node) {
+      void this.selectionTick;
+      return this.selection ? this.selection.isIndeterminate(node.id) : false;
+    },
+    bumpSelectionView() {
+      this.selectionTick += 1;
+    },
+    // activePath 只保留非叶子，避免多出一列空菜单（空列仍有 min-width 会撑出横向滚动）
+    sanitizeActivePath(pathIds) {
+      if (!this.store || !Array.isArray(pathIds)) {
+        return [];
+      }
+      return pathIds.filter(id => {
+        const node = this.store.nodeById.get(id);
+        return node && !node.isLeaf;
+      });
+    },
+    expandNode(node, silent = false) {
+      if (node.isLeaf) {
+        return;
+      }
+      const pathIds = [];
+      let current = node;
+      while (current) {
+        pathIds.unshift(current.id);
+        if (current.parentId == null) {
+          break;
+        }
+        current = this.store.nodeById.get(current.parentId);
+      }
+      this.activePath = this.sanitizeActivePath(pathIds);
+      if (!silent) {
+        const pathValues = pathIds.map(id => this.store.nodeById.get(id).value);
+        this.$emit('expand-change', pathValues);
+        if (this.autoExpandDeep) {
+          this.$nextTick(() => {
+            this.expandDeepFromNode(node);
+          });
+        }
+      }
+    },
+    expandDeepFromNode(node) {
+      if (!node || node.isLeaf) {
+        return;
+      }
+      const children = getStoreChildren(this.store, node.id);
+      if (children.length === 0) {
+        return;
+      }
+      const firstChild = children[0];
+      const pathIds = [];
+      let cursor = firstChild;
+      while (cursor) {
+        pathIds.push(cursor.id);
+        if (cursor.isLeaf) {
+          break;
+        }
+        const kids = getStoreChildren(this.store, cursor.id);
+        if (kids.length === 0) {
+          break;
+        }
+        cursor = kids[0];
+      }
+      const basePath = [];
+      let parent = node;
+      while (parent) {
+        basePath.unshift(parent.id);
+        if (parent.parentId == null) {
+          break;
+        }
+        parent = this.store.nodeById.get(parent.parentId);
+      }
+      this.activePath = this.sanitizeActivePath(basePath.concat(pathIds));
+    },
+    expandPathValues(pathValues, deep = true) {
+      if (!pathValues || pathValues.length === 0 || !this.store) {
+        return;
+      }
+      const node = findStoreNodeByPath(this.store, pathValues);
+      if (!node) {
+        return;
+      }
+      const pathIds = [];
+      let current = node;
+      while (current) {
+        pathIds.unshift(current.id);
+        if (current.parentId == null) {
+          break;
+        }
+        current = this.store.nodeById.get(current.parentId);
+      }
+      this.activePath = this.sanitizeActivePath(pathIds);
+      if (deep && this.autoExpandDeep) {
+        this.$nextTick(() => {
+          this.expandDeepFromNode(node);
+        });
+      }
+    },
+    onNodeClick(node, colIndex) {
+      if (node.disabled || this.isViewMode) {
+        return;
+      }
+      if (!this.multiple && !this.checkStrictly) {
+        if (node.isLeaf) {
+          this.selection.clear();
+          this.selection.toggleNode(node.id, true);
+          this.emitValue();
+        } else {
+          this.expandNode(node);
+        }
+        return;
+      }
+      this.expandNode(node);
+    },
+    onCheckClick(node, checked) {
+      if (!this.multiple || node.disabled || this.isViewMode) {
+        return;
+      }
+      const nextChecked = typeof checked === 'boolean' ? checked : !this.isChecked(node);
+      this.selection.toggleNode(node.id, nextChecked);
+      this.bumpSelectionView();
+      this.emitValue();
+
+      // 与 el-cascader-panel 一致：非 checkStrictly 时勾选会同步展开当前节点
+      if (!this.checkStrictly && !node.isLeaf) {
+        this.expandNode(node);
+      }
+    },
+    onRadioClick(node) {
+      if (this.multiple || node.disabled || this.isViewMode) {
+        return;
+      }
+      this.selection.clear();
+      this.selection.toggleNode(node.id, true);
+      this.emitValue();
+      if (!node.isLeaf) {
+        this.expandNode(node);
+      }
+    },
+    clearCheckedNodes() {
+      if (this.selection) {
+        this.selection.clear();
+        this.bumpSelectionView();
+        this.$emit('input', this.multiple ? [] : []);
+        this.$emit('change', this.multiple ? [] : []);
+      }
+    },
+    selectAllLeaves() {
+      if (this.selection) {
+        this.selection.selectAll();
+        this.bumpSelectionView();
+        this.emitValue();
+      }
+    },
+    syncCheckedValue() {
+      this.syncFromValue();
+    },
+    syncFromParentValues(values, prefix) {
+      if (!this.selection) {
+        return;
+      }
+      this.suppressValueSync = true;
+      this.selection.syncFromParentValues(values, prefix);
+      this.bumpSelectionView();
+      this.suppressValueSync = false;
+    },
+    getSelectionSnapshot() {
+      if (!this.selection || !this.store) {
+        return null;
+      }
+      return {
+        store: this.store,
+        selection: this.selection,
+        isCompact: this.selection.isCompactSelection(),
+        count: this.selection.size()
+      };
+    }
+  }
+});
+;// ./src/components/cascader-panel-pro/VirtualCascaderPanel.vue?vue&type=script&lang=js
+ /* harmony default export */ var cascader_panel_pro_VirtualCascaderPanelvue_type_script_lang_js = (VirtualCascaderPanelvue_type_script_lang_js); 
+;// ./src/components/cascader-panel-pro/VirtualCascaderPanel.vue
+
+
+
+
+
+/* normalize component */
+;
+var VirtualCascaderPanel_component = normalizeComponent(
+  cascader_panel_pro_VirtualCascaderPanelvue_type_script_lang_js,
+  VirtualCascaderPanelvue_type_template_id_23086f90_render,
+  VirtualCascaderPanelvue_type_template_id_23086f90_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var VirtualCascaderPanel = (VirtualCascaderPanel_component.exports);
+;// ./node_modules/thread-loader/dist/cjs.js!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/cascader-panel-pro/ByCascaderPanelPro.vue?vue&type=script&lang=js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* harmony default export */ var ByCascaderPanelProvue_type_script_lang_js = ({
+  name: 'ByCascaderPanelPro',
+  components: {
+    VirtualCascaderPanel: VirtualCascaderPanel,
+    VcpVirtualList: VirtualList
+  },
+  props: {
+    // 级联数据源
+    options: {
+      type: Array,
+      default: () => []
+    },
+    // 已选值
+    value: {
+      type: [Array, Number, String],
+      default: () => []
+    },
+    // 级联面板配置
+    cascaderProps: {
+      type: Object,
+      default: () => ({
+        multiple: true,
+        label: 'label',
+        value: 'value',
+        children: 'children'
+      })
+    },
+    // 面板高度
+    panelHeight: {
+      type: [String, Number],
+      default: 300,
+      validator: value => {
+        const numValue = Number(value);
+        if (isNaN(numValue)) {
+          console.warn(`[ByCascaderPanelPro] panelHeight 必须是数字，当前值: ${value}`);
+          return false;
+        }
+        if (numValue < 200) {
+          console.warn(`[ByCascaderPanelPro] panelHeight 不能小于 200px，当前值: ${value}px`);
+          return false;
+        }
+        if (numValue > 800) {
+          console.warn(`[ByCascaderPanelPro] panelHeight 不能大于 800px，当前值: ${value}px`);
+          return false;
+        }
+        return true;
+      }
+    },
+    // 搜索占位符
+    searchPlaceholder: {
+      type: String,
+      default: '请输入名称搜索'
+    },
+    // 禁用字段名（只针对叶子节点，非叶子节点为disabled）
+    disabledField: {
+      type: String,
+      default: 'disabled'
+    },
+    // 禁用值（只针对叶子节点，非叶子节点为disabled）
+    disabledValue: {
+      type: [String, Number, Boolean],
+      default: true
+    },
+    // 自定义禁用判断函数
+    disabledCheck: {
+      type: Function,
+      default: null
+    },
+    // 是否显示全选按钮
+    showSelectAll: {
+      type: Boolean,
+      default: true
+    },
+    // 是否聚合模式 (聚合模式下如果子项全部选中，会直接返回父ID)
+    aggregationMode: {
+      type: Boolean,
+      default: false
+    },
+    /**
+     * 非叶子节点前缀标识 (聚合模式下用于标识非叶子节点)
+     * 注意：聚合模式下，由于叶子节点和非叶子节点可能存在相同id,所以绑定数据中务必给非叶子节点加上parentNodePrefix前缀作为标识
+     */
+    parentNodePrefix: {
+      type: String,
+      default: '__parent__'
+    },
+    // 是否为查看模式 (如果是查看模式，则组件中的操作交互将全部禁用，仅用于回显查看)
+    isViewMode: {
+      type: Boolean,
+      default: false
+    },
+    // 是否显示子标题
+    showSubtitle: {
+      type: Boolean,
+      default: false
+    },
+    // 子标题字段名
+    subtitleField: {
+      type: String,
+      default: ''
+    },
+    // 级联列最小宽度（px）
+    columnMinWidth: {
+      type: Number,
+      default: 180
+    },
+    // 级联列最大宽度（px），超出后显示省略号
+    columnMaxWidth: {
+      type: Number,
+      default: 420
+    }
+  },
+  data() {
+    return {
+      selectedValues: [],
+      searchSelectedValues: [],
+      filteredOptions: [],
+      searchOptions: [],
+      selectedItems: [],
+      searchInput: '',
+      isShow: true,
+      isShowSearch: false,
+      totalCount: 0,
+      selectedCount: 0,
+      isAllSelected: false,
+      isInternalUpdate: false,
+      // 防止循环更新的标志
+      batchSearchVisible: false,
+      // 批量搜索弹窗显示状态
+      batchSearchContent: '',
+      // 批量搜索输入内容
+      compactPanelValue: [],
+      // 紧凑模式下稳定的空 value 引用，避免 watch 误触发清空
+      searchDebounceTimer: null,
+      searchLeafSetCache: null
+    };
+  },
+  computed: {
+    disabledConfig() {
+      return {
+        disabledField: this.disabledField,
+        disabledValue: this.disabledValue,
+        disabledCheck: this.disabledCheck
+      };
+    },
+    // 处理后的面板高度，确保在有效范围内
+    computedPanelHeight() {
+      const height = Number(this.panelHeight);
+      if (isNaN(height)) {
+        return 300; // 默认值
+      }
+      // 限制在 200px 到 800px 之间
+      return Math.max(200, Math.min(800, height));
+    },
+    // 是否为多选模式
+    isMultiple() {
+      return this.cascaderProps.multiple !== false;
+    },
+    useCompactSelection() {
+      return this.isMultiple && this.totalCount >= 300;
+    },
+    panelPresentationValue() {
+      if (this.useCompactSelection) {
+        return this.compactPanelValue;
+      }
+      if (this.isMultiple) {
+        return this.selectedValues;
+      }
+      return this.selectedValues.length > 0 ? this.selectedValues[0] : [];
+    },
+    compactSearchPanelValue() {
+      return this.compactPanelValue;
+    },
+    selectedItemHeight() {
+      return 40;
+    },
+    selectedListHeight() {
+      return Math.max(120, this.computedPanelHeight - 25);
+    },
+    // 当前选中的值（单选时返回单个值，多选时返回数组）
+    currentValue() {
+      if (this.isMultiple) {
+        return this.selectedItems.map(item => item.value);
+      } else {
+        return this.selectedItems.length > 0 ? this.selectedItems[0].value : null;
+      }
+    },
+    // 主面板的值（单选时返回单个路径，多选时返回路径数组）
+    mainPanelValue: {
+      get() {
+        if (this.isMultiple) {
+          return this.selectedValues;
+        } else {
+          return this.selectedValues.length > 0 ? this.selectedValues[0] : [];
+        }
+      },
+      set(value) {
+        if (this.isMultiple) {
+          this.selectedValues = value || [];
+        } else {
+          this.selectedValues = value ? [value] : [];
+        }
+      }
+    },
+    // 搜索面板的值（单选时返回单个路径，多选时返回路径数组）
+    searchPanelValue: {
+      get() {
+        if (this.isMultiple) {
+          return this.searchSelectedValues;
+        } else {
+          return this.searchSelectedValues.length > 0 ? this.searchSelectedValues[0] : [];
+        }
+      },
+      set(value) {
+        if (this.isMultiple) {
+          this.searchSelectedValues = value || [];
+        } else {
+          this.searchSelectedValues = value ? [value] : [];
+        }
+      }
+    }
+  },
+  watch: {
+    options: {
+      handler(newVal) {
+        this.initOptions();
+      },
+      deep: true,
+      immediate: true
+    },
+    value: {
+      handler(newVal) {
+        // 如果是内部更新触发的，跳过处理
+        if (this.isInternalUpdate) {
+          this.isInternalUpdate = false;
+          return;
+        }
+        this.processValue();
+      },
+      deep: true,
+      immediate: true
+    },
+    searchInput(val) {
+      if (!val) {
+        this.clearSearchState();
+        return;
+      }
+      this.scheduleSearch();
+    },
+    selectedItems: {
+      handler(newVal) {
+        if (this.isMultiple) {
+          const panel = this.$refs.cascaderPanel;
+          if (this.useCompactSelection && !this.aggregationMode && panel && panel.selection && panel.selection.isCompactSelection()) {
+            this.selectedCount = panel.selection.size();
+          } else {
+            this.selectedCount = newVal.length;
+          }
+          if (!this.useCompactSelection) {
+            if (this.aggregationMode) {
+              const config = {
+                disabledField: this.disabledField,
+                disabledValue: this.disabledValue,
+                disabledCheck: this.disabledCheck
+              };
+              this.isAllSelected = CascaderUtilsPro.isAggregatedAllSelected(this.selectedValues, this.filteredOptions, config, this.cascaderProps);
+            } else {
+              this.isAllSelected = this.selectedCount === this.totalCount;
+            }
+          }
+        } else {
+          if (newVal.length > 1) {
+            this.selectedItems = [newVal[newVal.length - 1]];
+          }
+          this.selectedCount = this.selectedItems.length;
+        }
+      },
+      deep: false
+    }
+  },
+  mounted() {
+    this.initOptions();
+    // 确保在 mounted 后处理默认值
+    this.$nextTick(() => {
+      this.processValue();
+    });
+    // 组件挂载后强制调整样式
+    this.forceVerticalCenter();
+  },
+  beforeDestroy() {
+    if (this.searchDebounceTimer) {
+      clearTimeout(this.searchDebounceTimer);
+      this.searchDebounceTimer = null;
+    }
+  },
+  methods: {
+    onMainPanelInput(value) {
+      if (this.useCompactSelection && Array.isArray(value) && value.length >= 300) {
+        return;
+      }
+      if (this.isMultiple) {
+        this.selectedValues = Array.isArray(value) ? value : [];
+      } else {
+        this.selectedValues = value && value.length ? [value] : [];
+      }
+    },
+    applyPanelSelectionChange() {
+      const panel = this.$refs.cascaderPanel;
+      if (!panel || !panel.store || !panel.selection) {
+        return;
+      }
+      const {
+        store,
+        selection
+      } = panel;
+      if (this.aggregationMode) {
+        const items = CascaderUtilsPro.getAggregatedItemsFromSelection(store, selection, this.filteredOptions, this.cascaderProps);
+        this.selectedItems = items;
+        this.selectedCount = items.length;
+        this.isAllSelected = selection.size() === store.totalLeafCount && store.totalLeafCount > 0;
+        if (!selection.isCompactSelection()) {
+          this.selectedValues = selection.getCheckedPaths();
+        }
+        this.isInternalUpdate = true;
+        let emitValue = CascaderUtilsPro.getAggregatedEmitValues(items, this.parentNodePrefix);
+        if (!this.isMultiple && emitValue.length > 0) {
+          emitValue = emitValue[0];
+        }
+        this.$emit('input', emitValue);
+        this.$emit('change', this.getSelectedData());
+        panel.bumpSelectionView();
+        return;
+      }
+      if (selection.isCompactSelection()) {
+        this.selectedItems = this.buildSelectedItemsFromValuesLazy(panel);
+        this.selectedCount = this.aggregationMode ? this.selectedItems.length : selection.size();
+        this.isAllSelected = selection.size() === store.totalLeafCount;
+        this.isInternalUpdate = true;
+        this.$emit('input', this.currentValue);
+        this.$emit('change', this.getSelectedData());
+        panel.bumpSelectionView();
+        return;
+      }
+      this.selectedValues = selection.getCheckedPaths();
+      this.updateSelectedItems();
+      panel.bumpSelectionView();
+      this.$nextTick(() => {
+        this.isInternalUpdate = true;
+        let emitValue = this.currentValue;
+        if (this.aggregationMode) {
+          emitValue = CascaderUtilsPro.getAggregatedEmitValues(this.selectedItems, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0];
+          }
+        }
+        this.$emit('input', emitValue);
+        this.$emit('change', this.getSelectedData());
+      });
+    },
+    buildSelectedItemsFromValuesLazy(panel) {
+      if (!panel || !panel.selection) {
+        return [];
+      }
+      if (!panel.selection.isCompactSelection()) {
+        return this.buildSelectedItemsFromValues();
+      }
+      return CascaderUtilsPro.buildSelectedItemsFromSelection(panel.store, panel.selection, this.filteredOptions, this.cascaderProps);
+    },
+    syncPanelFromExternalValue() {
+      const panel = this.$refs.cascaderPanel;
+      if (!panel || !panel.selection || !panel.store) {
+        return;
+      }
+      if (!Array.isArray(this.value) || this.value.length === 0) {
+        panel.clearCheckedNodes();
+        this.selectedItems = [];
+        this.selectedValues = [];
+        return;
+      }
+      const paths = this.resolveExternalValueToPaths();
+      panel.selection.clear();
+      paths.forEach(path => {
+        const leafValue = path[path.length - 1];
+        if (panel.store.pathByLeafValue.has(leafValue)) {
+          panel.selection.selectedLeafSet.add(leafValue);
+        }
+      });
+      panel.selection._reconcileAllRoots();
+      panel.bumpSelectionView();
+      this.applyPanelSelectionChange();
+      this.expandPanelToExternalValue(panel);
+    },
+    resolveExternalValueToPaths() {
+      if (!Array.isArray(this.value) || this.value.length === 0) {
+        return [];
+      }
+      if (typeof this.value[0] === 'string' || typeof this.value[0] === 'number') {
+        if (this.aggregationMode) {
+          return CascaderUtilsPro.processValuesWithParentNodes(this.value, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+        }
+        return this.findPathsByValues(this.value);
+      }
+      return [...this.value];
+    },
+    expandPanelToExternalValue(panel) {
+      if (!panel || !panel.store || !Array.isArray(this.value) || this.value.length === 0) {
+        return;
+      }
+      const firstValue = this.value[0];
+      let pathValues = [];
+      if (this.aggregationMode && CascaderUtilsPro.isParentNodeValue(firstValue, this.parentNodePrefix)) {
+        const actualValue = CascaderUtilsPro.extractParentNodeValue(firstValue, this.parentNodePrefix);
+        const node = panel.store.nodeByValue.get(actualValue);
+        pathValues = node ? [...node.path] : [];
+      } else if (panel.store.pathByLeafValue.has(firstValue)) {
+        const path = panel.store.pathByLeafValue.get(firstValue);
+        pathValues = path ? path.slice(0, -1) : [];
+      } else {
+        const node = panel.store.nodeByValue.get(firstValue);
+        if (node) {
+          pathValues = node.isLeaf ? node.path.slice(0, -1) : [...node.path];
+        }
+      }
+      if (pathValues.length > 0) {
+        this.$nextTick(() => {
+          panel.expandPathValues(pathValues, true);
+        });
+      }
+    },
+    onSearchPanelInput(value) {
+      if (this.useCompactSelection && Array.isArray(value) && value.length >= 300) {
+        return;
+      }
+      if (this.isMultiple) {
+        this.searchSelectedValues = Array.isArray(value) ? value : [];
+      } else {
+        this.searchSelectedValues = value && value.length ? [value] : [];
+      }
+    },
+    // 处理 value 值
+    processValue() {
+      if (this.useCompactSelection && this.isMultiple) {
+        this.selectedValues = [];
+        this.$nextTick(() => {
+          this.syncPanelFromExternalValue();
+        });
+        return;
+      }
+      if (this.isMultiple) {
+        // 多选模式：支持直接传入value值或路径数组
+        if (Array.isArray(this.value) && this.value.length > 0) {
+          if (typeof this.value[0] === 'string' || typeof this.value[0] === 'number') {
+            // 传入的是value值数组，需要转换为路径
+            if (this.aggregationMode) {
+              // 聚合模式下，支持非叶子节点标识
+              this.selectedValues = CascaderUtilsPro.processValuesWithParentNodes(this.value, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+            } else {
+              // 普通模式下，只处理叶子节点
+              this.selectedValues = this.findPathsByValues(this.value);
+            }
+          } else {
+            // 传入的是路径数组
+            this.selectedValues = [...this.value];
+          }
+        } else {
+          this.selectedValues = [];
+        }
+      } else {
+        // 单选模式：支持单个值或路径数组
+        if (this.value !== null && this.value !== undefined && this.value !== '') {
+          if (Array.isArray(this.value)) {
+            // 传入的是路径数组
+            this.selectedValues = [...this.value];
+          } else {
+            // 传入的是单个值，需要转换为路径
+            if (this.aggregationMode) {
+              // 聚合模式下，支持非叶子节点标识
+              this.selectedValues = CascaderUtilsPro.processValuesWithParentNodes([this.value], this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+            } else {
+              // 普通模式下，只处理叶子节点
+              this.selectedValues = this.findPathsByValues([this.value]);
+            }
+          }
+        } else {
+          this.selectedValues = [];
+        }
+      }
+      this.updateSelectedItems();
+
+      // 单选模式下，确保级联面板正确显示选中状态
+      if (!this.isMultiple && this.selectedValues.length > 0) {
+        this.$nextTick(() => {
+          const panel = this.$refs.cascaderPanel;
+          if (panel) {
+            panel.syncCheckedValue();
+            this.updateSelectedItems();
+          }
+        });
+      }
+    },
+    // 初始化选项数据
+    initOptions() {
+      this.filteredOptions = this.processOptions(this.options);
+      this.countTotalItems();
+      if (this.isMultiple && Array.isArray(this.value) && this.value.length > 0 && (this.useCompactSelection || this.$refs.cascaderPanel)) {
+        this.$nextTick(() => {
+          this.syncPanelFromExternalValue();
+        });
+      } else {
+        this.updateSelectedItems();
+      }
+    },
+    // 处理选项数据，添加禁用状态（浅拷贝，避免 JSON 深拷贝大数据卡顿）
+    processOptions(options) {
+      const childrenKey = this.cascaderProps && this.cascaderProps.children || 'children';
+      const disabledKey = this.cascaderProps && this.cascaderProps.disabled || 'disabled';
+      const config = this.disabledConfig;
+      const cloneItems = (items, ancestorDisabled = false) => {
+        return items.map(item => {
+          const isDisabled = ancestorDisabled || CascaderUtilsPro.isItemDisabled(item, config);
+          const children = item[childrenKey];
+          const cloned = {
+            ...item
+          };
+          if (this.isViewMode || isDisabled) {
+            cloned[disabledKey] = true;
+          }
+          if (children && children.length > 0) {
+            cloned[childrenKey] = cloneItems(children, isDisabled || this.isViewMode);
+          }
+          return cloned;
+        });
+      };
+      return cloneItems(options || []);
+    },
+    // 判断项目是否禁用
+    isItemDisabled(item) {
+      const config = {
+        disabledField: this.disabledField,
+        disabledValue: this.disabledValue,
+        disabledCheck: this.disabledCheck
+      };
+      return CascaderUtilsPro.isItemDisabled(item, config);
+    },
+    // 统计总项目数
+    countTotalItems() {
+      const config = {
+        disabledField: this.disabledField,
+        disabledValue: this.disabledValue,
+        disabledCheck: this.disabledCheck
+      };
+      this.totalCount = CascaderUtilsPro.countTotalItems(this.filteredOptions, config, this.cascaderProps);
+    },
+    // 更新已选项列表
+    updateSelectedItems() {
+      this.$nextTick(() => {
+        const panel = this.$refs.cascaderPanel;
+        if (this.aggregationMode) {
+          if (panel && panel.store && panel.selection) {
+            this.selectedItems = CascaderUtilsPro.getAggregatedItemsFromSelection(panel.store, panel.selection, this.filteredOptions, this.cascaderProps);
+          } else {
+            this.selectedItems = CascaderUtilsPro.getAggregatedSelectedItems(this.selectedValues, this.filteredOptions, this.cascaderProps);
+          }
+        } else {
+          this.selectedItems = this.buildSelectedItemsFromValues();
+        }
+      });
+    },
+    // 基于 selectedValues 构建已选项列表
+    buildSelectedItemsFromValues() {
+      return CascaderUtilsPro.buildSelectedItemsFromValues(this.selectedValues, this.filteredOptions, this.cascaderProps);
+    },
+    // 搜索处理（防抖，避免每次按键遍历整棵树）
+    scheduleSearch() {
+      if (this.searchDebounceTimer) {
+        clearTimeout(this.searchDebounceTimer);
+      }
+      this.searchDebounceTimer = setTimeout(() => {
+        this.searchDebounceTimer = null;
+        this.runSearch();
+      }, 100);
+    },
+    clearSearchState() {
+      if (this.searchDebounceTimer) {
+        clearTimeout(this.searchDebounceTimer);
+        this.searchDebounceTimer = null;
+      }
+      this.isShowSearch = false;
+      this.searchOptions = [];
+      this.searchLeafSetCache = null;
+      this.searchSelectedValues = [];
+    },
+    runSearch() {
+      const keyword = this.searchInput.trim();
+      if (!keyword) {
+        this.clearSearchState();
+        return;
+      }
+      const panel = this.$refs.cascaderPanel;
+      if (panel && panel.store) {
+        this.searchOptions = CascaderUtilsPro.searchFromStore(panel.store, keyword, this.cascaderProps);
+      } else {
+        this.searchOptions = CascaderUtilsPro.searchInTree(this.filteredOptions, keyword, this.cascaderProps);
+      }
+      this.searchLeafSetCache = new Set(CascaderUtilsPro.getLeafValues(this.searchOptions, this.cascaderProps));
+      this.searchSelectedValues = this.getSearchSelectedPathsFromMain(this.searchLeafSetCache);
+      this.isShowSearch = true;
+      this.$nextTick(() => {
+        if (this.searchOptions.length > 0) {
+          this.syncSearchPanelSelection();
+          this.handleSearchExpand();
+        }
+      });
+    },
+    getSearchSelectedPathsFromMain(searchLeafSet) {
+      const panel = this.$refs.cascaderPanel;
+      if (panel && panel.selection && panel.store) {
+        const paths = [];
+        panel.selection.selectedLeafSet.forEach(leaf => {
+          if (searchLeafSet.has(leaf)) {
+            const path = panel.store.pathByLeafValue.get(leaf);
+            if (path) {
+              paths.push(path);
+            }
+          }
+        });
+        return paths;
+      }
+      return CascaderUtilsPro.getSearchSelectedValues(this.selectedValues, this.searchOptions, this.cascaderProps);
+    },
+    getSearchLeafSet() {
+      if (this.searchLeafSetCache) {
+        return this.searchLeafSetCache;
+      }
+      return new Set(CascaderUtilsPro.getLeafValues(this.searchOptions, this.cascaderProps));
+    },
+    syncSearchPanelSelection() {
+      const searchPanel = this.$refs.searchCascaderPanel;
+      const mainPanel = this.$refs.cascaderPanel;
+      if (!searchPanel || !mainPanel || !searchPanel.selection || !mainPanel.selection) {
+        return;
+      }
+      const searchLeafSet = this.getSearchLeafSet();
+      searchPanel.selection.clear();
+      mainPanel.selection.selectedLeafSet.forEach(leaf => {
+        if (searchLeafSet.has(leaf)) {
+          searchPanel.selection.selectedLeafSet.add(leaf);
+        }
+      });
+      searchPanel.selection._reconcileAllRoots();
+      searchPanel.bumpSelectionView();
+    },
+    // 搜索模式下的展开处理
+    handleSearchExpand() {
+      if (this.$refs.searchCascaderPanel && this.searchOptions.length > 0) {
+        const firstOption = this.searchOptions[0];
+        const valueKey = this.cascaderProps.value || 'value';
+        this.$refs.searchCascaderPanel.expandPathValues([firstOption[valueKey]], true);
+      }
+    },
+    // 值变化处理
+    handleValueChange() {
+      this.applyPanelSelectionChange();
+    },
+    // 搜索模式值变化处理
+    handleSearchValueChange() {
+      const searchPanel = this.$refs.searchCascaderPanel;
+      const mainPanel = this.$refs.cascaderPanel;
+      if (!searchPanel || !mainPanel || !searchPanel.selection || !mainPanel.selection) {
+        return;
+      }
+      const searchLeafSet = this.getSearchLeafSet();
+      searchLeafSet.forEach(leaf => {
+        const shouldSelect = searchPanel.selection.selectedLeafSet.has(leaf);
+        const isSelected = mainPanel.selection.selectedLeafSet.has(leaf);
+        if (shouldSelect && !isSelected) {
+          mainPanel.selection.selectedLeafSet.add(leaf);
+        } else if (!shouldSelect && isSelected) {
+          mainPanel.selection.selectedLeafSet.delete(leaf);
+        }
+      });
+      mainPanel.selection._reconcileAllRoots();
+      mainPanel.bumpSelectionView();
+      this.applyPanelSelectionChange();
+    },
+    // 移除已选项
+    removeItem(item, index) {
+      const panel = this.$refs.cascaderPanel;
+      if (panel && panel.selection) {
+        if (item.isAggregated) {
+          const node = panel.store.nodeByValue.get(item.value);
+          if (node) {
+            panel.selection.toggleNode(node.id, false);
+          }
+        } else if (item.path && item.path.length > 0) {
+          const leafValue = item.path[item.path.length - 1];
+          const leafNode = panel.store.nodeByValue.get(leafValue);
+          if (leafNode) {
+            panel.selection.toggleNode(leafNode.id, false);
+          } else {
+            const node = panel.store.nodeByValue.get(item.value);
+            if (node) {
+              panel.selection.toggleNode(node.id, false);
+            }
+          }
+        } else {
+          const node = panel.store.nodeByValue.get(item.value);
+          if (node) {
+            panel.selection.toggleNode(node.id, false);
+          }
+        }
+        this.applyPanelSelectionChange();
+        if (this.isShowSearch) {
+          this.syncSearchPanelSelection();
+        }
+        return;
+      }
+      const valueToRemove = item.value;
+      this.selectedValues = this.selectedValues.filter(path => {
+        return !path.includes(valueToRemove);
+      });
+      this.searchSelectedValues = this.searchSelectedValues.filter(path => {
+        return !path.includes(valueToRemove);
+      });
+      this.selectedItems.splice(index, 1);
+      this.$nextTick(() => {
+        this.isInternalUpdate = true;
+        let emitValue = this.currentValue;
+        if (this.aggregationMode) {
+          emitValue = CascaderUtilsPro.getAggregatedEmitValues(this.selectedItems, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0];
+          }
+        }
+        this.$emit('input', emitValue);
+      });
+    },
+    // 全选/取消全选
+    handleSelectAll() {
+      if (!this.isMultiple) {
+        // 单选模式下不支持全选
+        return;
+      }
+      if (this.isAllSelected) {
+        const panel = this.$refs.cascaderPanel;
+        if (panel) {
+          panel.clearCheckedNodes();
+        } else {
+          this.selectedValues = [];
+          this.selectedItems = [];
+          this.searchSelectedValues = [];
+          this.applyPanelSelectionChange();
+        }
+      } else {
+        const panel = this.$refs.cascaderPanel;
+        if (panel) {
+          panel.selectAllLeaves();
+        } else {
+          this.selectedValues = CascaderUtilsPro.getAllLeafPaths(this.filteredOptions, this.disabledConfig, this.cascaderProps);
+          this.updateSelectedItems();
+          this.applyPanelSelectionChange();
+        }
+      }
+    },
+    // 获取选中的数据
+    getSelectedData() {
+      let values = this.currentValue;
+      let valuesPath = this.selectedValues;
+      if (!this.aggregationMode && this.selectedItems.length > 0 && valuesPath.length === 0) {
+        valuesPath = this.selectedItems.map(item => item.path);
+      }
+      if (this.aggregationMode) {
+        values = CascaderUtilsPro.getAggregatedEmitValues(this.selectedItems, this.parentNodePrefix);
+        valuesPath = this.selectedItems.map(item => item.path);
+        if (!this.isMultiple && values.length > 0) {
+          values = values[0];
+        }
+      }
+      return {
+        valuesPath,
+        values,
+        items: this.selectedItems,
+        count: this.selectedItems.length
+      };
+    },
+    // 清空选择
+    clearSelection() {
+      const panel = this.$refs.cascaderPanel;
+      if (panel) {
+        panel.clearCheckedNodes();
+      } else {
+        this.selectedValues = [];
+        this.selectedItems = [];
+        this.searchSelectedValues = [];
+        this.applyPanelSelectionChange();
+      }
+    },
+    // 设置选择值
+    setValue(values) {
+      if (this.isMultiple) {
+        // 多选模式：支持直接传入value值或路径数组
+        if (Array.isArray(values) && values.length > 0) {
+          if (typeof values[0] === 'string' || typeof values[0] === 'number') {
+            // 传入的是value值数组，需要转换为路径
+            if (this.aggregationMode) {
+              // 聚合模式下，支持非叶子节点标识
+              this.selectedValues = CascaderUtilsPro.processValuesWithParentNodes(values, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+            } else {
+              // 普通模式下，只处理叶子节点
+              this.selectedValues = this.findPathsByValues(values);
+            }
+          } else {
+            // 传入的是路径数组
+            this.selectedValues = [...values];
+          }
+        } else {
+          this.selectedValues = [];
+        }
+      } else {
+        // 单选模式：支持单个值或路径数组
+        if (values !== null && values !== undefined && values !== '') {
+          if (Array.isArray(values)) {
+            // 传入的是路径数组
+            this.selectedValues = [...values];
+          } else {
+            // 传入的是单个值，需要转换为路径
+            if (this.aggregationMode) {
+              // 聚合模式下，支持非叶子节点标识
+              this.selectedValues = CascaderUtilsPro.processValuesWithParentNodes([values], this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+            } else {
+              // 普通模式下，只处理叶子节点
+              this.selectedValues = this.findPathsByValues([values]);
+            }
+          }
+        } else {
+          this.selectedValues = [];
+        }
+      }
+      this.updateSelectedItems();
+    },
+    // 根据values找到对应的路径
+    findPathsByValues(values) {
+      const paths = [];
+      const findPath = (options, targetValues, currentPath = []) => {
+        for (const option of options) {
+          const newPath = [...currentPath, option[this.cascaderProps.value]];
+          if (targetValues.includes(option[this.cascaderProps.value])) {
+            // 如果是叶子节点（没有children属性），添加到路径中
+            if (!option[this.cascaderProps.children]) {
+              paths.push(newPath);
+            }
+          }
+
+          // 递归查找子节点
+          if (option[this.cascaderProps.children] && option[this.cascaderProps.children].length > 0) {
+            findPath(option[this.cascaderProps.children], targetValues, newPath);
+          }
+        }
+      };
+
+      // 使用 filteredOptions 如果存在，否则使用原始 options
+      const optionsToSearch = this.filteredOptions.length > 0 ? this.filteredOptions : this.options;
+      findPath(optionsToSearch, values);
+      return paths;
+    },
+    // 处理批量搜索弹窗显示
+    handleBatchSearchShow() {
+      if (this.searchInput) {
+        this.searchInput = '';
+      }
+    },
+    // 处理批量搜索
+    handleBatchSearch() {
+      if (!this.batchSearchContent.trim()) {
+        this.batchSearchVisible = false;
+        return;
+      }
+
+      // 分割输入内容（支持换行、逗号、分号等分隔符）
+      const inputNames = this.batchSearchContent.split(/[\n,;，；\s]+/).filter(item => item.trim()).map(item => item.trim());
+      if (inputNames.length === 0) {
+        this.batchSearchVisible = false;
+        return;
+      }
+
+      // 在级联数据中搜索匹配的名称
+      const matchedPaths = this.searchNamesInCascader(inputNames);
+      if (matchedPaths.length > 0) {
+        const panel = this.$refs.cascaderPanel;
+        if (panel && panel.selection && panel.store) {
+          matchedPaths.forEach(path => {
+            const leafValue = path[path.length - 1];
+            if (panel.store.pathByLeafValue.has(leafValue)) {
+              panel.selection.selectedLeafSet.add(leafValue);
+            }
+          });
+          panel.selection._reconcileAllRoots();
+          panel.bumpSelectionView();
+          this.applyPanelSelectionChange();
+        } else {
+          const newSelectedValues = [...this.selectedValues];
+          matchedPaths.forEach(path => {
+            const exists = newSelectedValues.some(existingPath => existingPath.length === path.length && existingPath.every((value, index) => value === path[index]));
+            if (!exists) {
+              newSelectedValues.push(path);
+            }
+          });
+          this.selectedValues = newSelectedValues;
+          this.updateSelectedItems();
+          this.$nextTick(() => {
+            this.isInternalUpdate = true;
+            let emitValue = this.currentValue;
+            if (this.aggregationMode) {
+              emitValue = CascaderUtilsPro.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+              if (!this.isMultiple && emitValue.length > 0) {
+                emitValue = emitValue[0];
+              }
+            }
+            this.$emit('input', emitValue);
+          });
+        }
+      }
+
+      // 关闭弹窗并清空内容
+      this.batchSearchVisible = false;
+      this.batchSearchContent = '';
+    },
+    // 在级联数据中搜索匹配的名称（全匹配，忽略空格，排除禁用项）
+    searchNamesInCascader(names) {
+      const matchedPaths = [];
+      const labelKey = this.cascaderProps.label || 'label';
+      const searchInOptions = (options, currentPath = []) => {
+        for (const option of options) {
+          const newPath = [...currentPath, option[this.cascaderProps.value]];
+          const optionLabel = String(option[labelKey] || '').replace(/\s+/g, ''); // 去掉所有空格
+
+          // 检查是否全匹配任何输入的名称（去掉空格后比较）
+          const isMatched = names.some(name => {
+            const cleanName = name.replace(/\s+/g, ''); // 去掉输入名称中的空格
+            return optionLabel.toLowerCase() === cleanName.toLowerCase();
+          });
+
+          // 检查是否为叶子节点且匹配且未禁用
+          const isLeafNode = !option[this.cascaderProps.children];
+          const isNotDisabled = !this.isItemDisabled(option);
+          if (isMatched && isLeafNode && isNotDisabled) {
+            // 如果是叶子节点、匹配且未禁用，添加到结果中
+            matchedPaths.push(newPath);
+          }
+
+          // 递归搜索子节点
+          if (option[this.cascaderProps.children] && option[this.cascaderProps.children].length > 0) {
+            searchInOptions(option[this.cascaderProps.children], newPath);
+          }
+        }
+      };
+      searchInOptions(this.filteredOptions);
+      return matchedPaths;
+    },
+    // 强制调整已选项的垂直居中样式
+    forceVerticalCenter() {
+      this.$nextTick(() => {
+        const itemLabels = this.$el.querySelectorAll('.item-label');
+        itemLabels.forEach(label => {
+          if (label) {
+            // 使用JavaScript强制设置样式
+            label.style.setProperty('display', 'flex', 'important');
+            label.style.setProperty('align-items', 'center', 'important');
+            label.style.setProperty('height', '36px', 'important');
+            label.style.setProperty('line-height', '36px', 'important');
+            label.style.setProperty('margin', '0', 'important');
+            label.style.setProperty('padding', '0', 'important');
+            label.style.setProperty('vertical-align', 'middle', 'important');
+            label.style.setProperty('font-size', '14px', 'important');
+          }
+        });
+      });
+    }
+  },
+  updated() {
+    // 组件更新后强制调整样式
+    this.forceVerticalCenter();
+  }
+});
+;// ./src/components/cascader-panel-pro/ByCascaderPanelPro.vue?vue&type=script&lang=js
+ /* harmony default export */ var cascader_panel_pro_ByCascaderPanelProvue_type_script_lang_js = (ByCascaderPanelProvue_type_script_lang_js); 
+;// ./src/components/cascader-panel-pro/ByCascaderPanelPro.vue
+
+
+
+
+
+/* normalize component */
+;
+var ByCascaderPanelPro_component = normalizeComponent(
+  cascader_panel_pro_ByCascaderPanelProvue_type_script_lang_js,
+  ByCascaderPanelProvue_type_template_id_4bdb9820_render,
+  ByCascaderPanelProvue_type_template_id_4bdb9820_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var ByCascaderPanelPro = (ByCascaderPanelPro_component.exports);
 ;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"8cd600e8-vue-loader-template"}!./node_modules/babel-loader/lib/index.js??clonedRuleSet-40.use[1]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/loaders/templateLoader.js??ruleSet[1].rules[3]!./node_modules/cache-loader/dist/cjs.js??ruleSet[0].use[0]!./node_modules/@vue/cli-service/node_modules/@vue/vue-loader-v15/lib/index.js??vue-loader-options!./src/components/floating-menu/ByFloatingMenu.vue?vue&type=template&id=04723f13
 var ByFloatingMenuvue_type_template_id_04723f13_render = function render() {
   var _vm = this,
@@ -98709,6 +101902,7 @@ var ByCardSelector_component = normalizeComponent(
 
 
 
+
 
 
 const components = {
@@ -98726,6 +101920,7 @@ const components = {
   ByTreeSearch: ByTreeSearch,
   ByDialog: ByDialog,
   ByCascaderPanel: ByCascaderPanel,
+  ByCascaderPanelPro: ByCascaderPanelPro,
   ByFloatingMenu: ByFloatingMenu,
   ByPopoverSelector: ByPopoverSelector,
   ByGridLayout: ByGridLayout,