@weitutech/by-components 1.1.96 → 1.1.98

package/lib/by-components.common.js

@@ -60503,6 +60503,7 @@ __webpack_require__.r(__webpack_exports__);
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
   ByBatchQuerySelector: function() { return /* reexport */ BatchQuerySelector; },
+  ByCascaderPanel: function() { return /* reexport */ ByCascaderPanel; },
   ByCommonSelector: function() { return /* reexport */ ByCommonSelector; },
   ByCustomDatePicker: function() { return /* reexport */ custom_date_picker; },
   ByDatePickerRange: function() { return /* reexport */ date_picker_range; },
@@ -76932,8 +76933,8 @@ var ByTreeSearch_component = normalizeComponent(
 )
 
 /* harmony default export */ var ByTreeSearch = (ByTreeSearch_component.exports);
-;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"ffbc40de-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/by-dialog/ByDialog.vue?vue&type=template&id=7a5fdd30
-var ByDialogvue_type_template_id_7a5fdd30_render = function render() {
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"ffbc40de-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/by-dialog/ByDialog.vue?vue&type=template&id=75a24552
+var ByDialogvue_type_template_id_75a24552_render = function render() {
   var _vm = this,
     _c = _vm._self._c;
   return _c('el-dialog', _vm._g(_vm._b({
@@ -76950,11 +76951,9 @@ var ByDialogvue_type_template_id_7a5fdd30_render = function render() {
     }
   }, 'el-dialog', _vm.dialogAttrs, false), _vm.$listeners), [_c('div', {
     staticClass: "by-dialog__body"
-  }, [_vm._t("default", function () {
-    return [_vm.content ? _c('div', {
-      staticClass: "by-dialog__content"
-    }, [_vm._v(_vm._s(_vm.content))]) : _vm._e()];
-  })], 2), _vm.showFooter ? _c('div', {
+  }, [_vm.content ? _c('div', {
+    staticClass: "by-dialog__content"
+  }, [_vm._v(_vm._s(_vm.content))]) : _vm._e(), _vm._t("default")], 2), _vm.showFooter ? _c('div', {
     staticClass: "by-dialog__footer"
   }, [_c('div', {
     staticClass: "by-dialog__buttons"
@@ -76965,7 +76964,7 @@ var ByDialogvue_type_template_id_7a5fdd30_render = function render() {
       style: button.style,
       attrs: {
         "type": button.type || 'default',
-        "size": button.size || 'medium',
+        "size": button.size || 'mini',
         "loading": button.loading,
         "disabled": button.disabled,
         "icon": button.icon
@@ -76978,7 +76977,7 @@ var ByDialogvue_type_template_id_7a5fdd30_render = function render() {
     }, [_vm._v(" " + _vm._s(button.text) + " ")])];
   })], 2), _vm._t("footer")], 2) : _vm._e()]);
 };
-var ByDialogvue_type_template_id_7a5fdd30_staticRenderFns = [];
+var ByDialogvue_type_template_id_75a24552_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/by-dialog/ByDialog.vue?vue&type=script&lang=js
 /* harmony default export */ var ByDialogvue_type_script_lang_js = ({
@@ -77117,8 +77116,8 @@ var ByDialogvue_type_template_id_7a5fdd30_staticRenderFns = [];
 ;
 var ByDialog_component = normalizeComponent(
   by_dialog_ByDialogvue_type_script_lang_js,
-  ByDialogvue_type_template_id_7a5fdd30_render,
-  ByDialogvue_type_template_id_7a5fdd30_staticRenderFns,
+  ByDialogvue_type_template_id_75a24552_render,
+  ByDialogvue_type_template_id_75a24552_staticRenderFns,
   false,
   null,
   null,
@@ -77518,6 +77517,1478 @@ ByDialogService.install = function (Vue) {
   Vue.prototype.$byDialog = ByDialogService;
 };
 /* harmony default export */ var by_dialog_ByDialogService = (ByDialogService);
+;// ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"ffbc40de-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/ByCascaderPanel.vue?vue&type=template&id=d3dd0512
+var ByCascaderPanelvue_type_template_id_d3dd0512_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    staticClass: "by-cascader-panel"
+  }, [_c('div', {
+    staticClass: "cascade-box row"
+  }, [_c('div', {
+    staticClass: "cascade-container left-panel"
+  }, [_c('div', {
+    staticClass: "cascade-title row column-c"
+  }, [!_vm.aggregationMode ? _c('div', {
+    staticClass: "txt"
+  }, [_vm._v("可选(" + _vm._s(_vm.selectedCount) + "/" + _vm._s(_vm.totalCount) + ")")]) : _vm._e(), _c('div', {
+    staticClass: "cell",
+    staticStyle: {
+      "padding-left": "20px"
+    }
+  }, [_c('el-input', {
+    staticClass: "search-input",
+    attrs: {
+      "placeholder": _vm.searchPlaceholder,
+      "clearable": ""
+    },
+    on: {
+      "input": _vm.handleSearch
+    },
+    model: {
+      value: _vm.searchInput,
+      callback: function ($$v) {
+        _vm.searchInput = $$v;
+      },
+      expression: "searchInput"
+    }
+  })], 1), _c('div', {
+    staticClass: "menu"
+  }, [_vm.searchInput === '' && _vm.isMultiple && _vm.showSelectAll ? _c('div', {
+    staticClass: "all-select",
+    on: {
+      "click": _vm.handleSelectAll
+    }
+  }, [_vm._v(" " + _vm._s(_vm.isAllSelected ? '取消全选' : '全选') + " ")]) : _vm._e()])]), _c('div', {
+    staticClass: "cascade-content",
+    staticStyle: {
+      "border": "1px solid #dcdfe6",
+      "overflow-x": "scroll",
+      "padding": "20px 20px 20px 20px"
+    },
+    style: {
+      height: _vm.computedPanelHeight + 'px'
+    }
+  }, [_c('div', [_vm.isShow && _vm.filteredOptions.length > 0 ? _c('el-cascader-panel', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.searchInput === '' || !_vm.isShowSearch,
+      expression: "searchInput === '' || !isShowSearch"
+    }],
+    ref: "cascaderPanel",
+    staticClass: "singleCascader",
+    style: {
+      height: _vm.computedPanelHeight - 50 + 'px'
+    },
+    attrs: {
+      "append-to-body": false,
+      "options": _vm.filteredOptions,
+      "props": _vm.cascaderProps
+    },
+    on: {
+      "expand-change": _vm.handleExpandChange,
+      "change": _vm.handleValueChange
+    },
+    model: {
+      value: _vm.mainPanelValue,
+      callback: function ($$v) {
+        _vm.mainPanelValue = $$v;
+      },
+      expression: "mainPanelValue"
+    }
+  }) : _vm._e(), _vm.searchOptions.length > 0 ? _c('el-cascader-panel', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.searchInput !== '' && _vm.isShowSearch,
+      expression: "searchInput !== '' && isShowSearch"
+    }],
+    ref: "searchCascaderPanel",
+    staticClass: "singleCascader",
+    style: {
+      height: _vm.computedPanelHeight - 50 + 'px'
+    },
+    attrs: {
+      "append-to-body": false,
+      "options": _vm.searchOptions,
+      "props": _vm.cascaderProps
+    },
+    on: {
+      "expand-change": _vm.handleExpandChange,
+      "change": _vm.handleSearchValueChange
+    },
+    model: {
+      value: _vm.searchPanelValue,
+      callback: function ($$v) {
+        _vm.searchPanelValue = $$v;
+      },
+      expression: "searchPanelValue"
+    }
+  }) : _vm._e()], 1), _vm.isShowSearch && _vm.searchOptions.length === 0 ? _c('div', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.searchInput !== '',
+      expression: "searchInput !== ''"
+    }],
+    staticClass: "row column-c row-c",
+    staticStyle: {
+      "width": "100%",
+      "height": "100%"
+    }
+  }, [_c('el-empty', {
+    attrs: {
+      "image-size": 100
+    }
+  })], 1) : _vm._e()])]), _c('div', {
+    staticClass: "cascade-container bb right-panel"
+  }, [_c('div', {
+    staticClass: "cascade-title row column-c"
+  }, [_c('div', {
+    staticClass: "txt"
+  }, [_vm._v("已选(" + _vm._s(_vm.selectedItems.length) + ")")]), _c('div', {
+    staticClass: "menu"
+  }, [_vm.selectedItems.length > 0 ? _c('div', {
+    staticClass: "clear-btn",
+    on: {
+      "click": _vm.clearSelection
+    }
+  }, [_vm._v("清除")]) : _vm._e()])]), _c('div', {
+    staticClass: "cascade-content",
+    style: {
+      height: _vm.computedPanelHeight - 5 + 'px'
+    }
+  }, [_c('div', {
+    staticClass: "item",
+    staticStyle: {
+      "overflow-y": "auto",
+      "height": "100%",
+      "max-height": "100%"
+    }
+  }, _vm._l(_vm.selectedItems, function (item, index) {
+    return _c('div', {
+      key: item.value,
+      staticClass: "check-box row column-c",
+      staticStyle: {
+        "height": "36px",
+        "flex-shrink": "0"
+      }
+    }, [_c('div', {
+      staticClass: "cell",
+      staticStyle: {
+        "white-space": "nowrap",
+        "overflow": "hidden",
+        "text-overflow": "ellipsis"
+      }
+    }, [_vm._v(" " + _vm._s(item.label || '') + " ")]), _c('div', {
+      staticClass: "icon",
+      staticStyle: {
+        "cursor": "pointer"
+      },
+      on: {
+        "click": function ($event) {
+          return _vm.removeItem(item, index);
+        }
+      }
+    }, [_c('i', {
+      staticClass: "el-icon-close"
+    })])]);
+  }), 0)])])])]);
+};
+var ByCascaderPanelvue_type_template_id_d3dd0512_staticRenderFns = [];
+
+;// ./src/utils/cascaderUtils.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * 级联选择器工具类
+ */
+class CascaderUtils {
+  /**
+   * 判断项目是否禁用
+   * @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 = [];
+    tree.forEach(node => {
+      if (node[cascaderProps.label].includes(keyword)) {
+        const matchedNode = {
+          ...node
+        };
+        result.push(matchedNode);
+      } else if (node[cascaderProps.children]) {
+        const matchedChildren = this.searchInTree(node[cascaderProps.children], keyword, cascaderProps);
+        if (matchedChildren.length > 0) {
+          const matchedNode = {
+            ...node,
+            [cascaderProps.children]: matchedChildren
+          };
+          result.push(matchedNode);
+        }
+      }
+    });
+    return result;
+  }
+
+  /**
+   * 获取叶子节点的值
+   * @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({
+            value: leafValue,
+            label: node[cascaderProps.label],
+            path: 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 {
+      // 基本属性
+      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 // 在级联面板中会动态设置
+    };
+  }
+
+  /**
+   * 获取聚合模式下的选中项（如果父项完全选中，则只返回父项）
+   * @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/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/ByCascaderPanel.vue?vue&type=script&lang=js
+
+
+
+
+
+
+/* harmony default export */ var ByCascaderPanelvue_type_script_lang_js = ({
+  name: 'ByCascaderPanel',
+  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(`[ByCascaderPanel] panelHeight 必须是数字，当前值: ${value}`);
+          return false;
+        }
+        if (numValue < 200) {
+          console.warn(`[ByCascaderPanel] panelHeight 不能小于 200px，当前值: ${value}px`);
+          return false;
+        }
+        if (numValue > 800) {
+          console.warn(`[ByCascaderPanel] 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__'
+    }
+  },
+  data() {
+    return {
+      selectedValues: [],
+      searchSelectedValues: [],
+      filteredOptions: [],
+      searchOptions: [],
+      selectedItems: [],
+      searchInput: '',
+      isShow: true,
+      isShowSearch: false,
+      totalCount: 0,
+      selectedCount: 0,
+      isAllSelected: false,
+      isInternalUpdate: false // 防止循环更新的标志
+    };
+  },
+  computed: {
+    // 处理后的面板高度，确保在有效范围内
+    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;
+    },
+    // 当前选中的值（单选时返回单个值，多选时返回数组）
+    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
+    },
+    selectedItems: {
+      handler(newVal) {
+        if (this.isMultiple) {
+          this.selectedCount = newVal.length;
+
+          // 聚合模式下的全选判断
+          if (this.aggregationMode) {
+            const config = {
+              disabledField: this.disabledField,
+              disabledValue: this.disabledValue,
+              disabledCheck: this.disabledCheck
+            };
+            this.isAllSelected = CascaderUtils.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;
+        }
+        this.$emit('change', this.getSelectedData());
+      },
+      deep: true
+    }
+  },
+  mounted() {
+    this.initOptions();
+    // 确保在 mounted 后处理默认值
+    this.$nextTick(() => {
+      this.processValue();
+    });
+  },
+  methods: {
+    // 处理 value 值
+    processValue() {
+      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 = CascaderUtils.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 = CascaderUtils.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.$forceUpdate();
+            // 再次更新已选项列表，确保右侧面板显示正确
+            this.updateSelectedItems();
+          }
+        });
+      }
+    },
+    // 初始化选项数据
+    initOptions() {
+      this.filteredOptions = this.processOptions(this.options);
+      this.countTotalItems();
+      this.updateSelectedItems();
+    },
+    // 处理选项数据，添加禁用状态
+    processOptions(options) {
+      const processedOptions = JSON.parse(JSON.stringify(options));
+      const config = {
+        disabledField: this.disabledField,
+        disabledValue: this.disabledValue,
+        disabledCheck: this.disabledCheck
+      };
+      CascaderUtils.setDisabledItems(processedOptions, config, this.cascaderProps);
+      return processedOptions;
+    },
+    // 判断项目是否禁用
+    isItemDisabled(item) {
+      const config = {
+        disabledField: this.disabledField,
+        disabledValue: this.disabledValue,
+        disabledCheck: this.disabledCheck
+      };
+      return CascaderUtils.isItemDisabled(item, config);
+    },
+    // 统计总项目数
+    countTotalItems() {
+      const config = {
+        disabledField: this.disabledField,
+        disabledValue: this.disabledValue,
+        disabledCheck: this.disabledCheck
+      };
+      this.totalCount = CascaderUtils.countTotalItems(this.filteredOptions, config, this.cascaderProps);
+    },
+    // 更新已选项列表
+    updateSelectedItems() {
+      this.$nextTick(() => {
+        if (this.isShowSearch) {
+          // 搜索模式下，基于 selectedValues 构建已选项列表
+          if (this.aggregationMode) {
+            // 聚合模式：使用聚合逻辑处理选中项
+            this.selectedItems = CascaderUtils.getAggregatedSelectedItems(this.selectedValues, this.filteredOptions, this.cascaderProps);
+          } else {
+            this.selectedItems = this.buildSelectedItemsFromValues();
+          }
+        } else {
+          // 正常模式下，优先从面板获取选中项，如果面板没有选中项则基于 selectedValues 构建
+          const panel = this.$refs.cascaderPanel;
+          if (panel) {
+            const checkedNodes = panel.getCheckedNodes();
+            if (this.aggregationMode) {
+              // 聚合模式：使用聚合逻辑处理选中项
+              this.selectedItems = CascaderUtils.getAggregatedSelectedItems(this.selectedValues, this.filteredOptions, this.cascaderProps);
+            } else {
+              // 普通模式：只显示叶子节点（最后一级），过滤掉父节点
+              const panelSelectedItems = checkedNodes.filter(node => {
+                // 如果是叶子节点（没有children属性），则显示
+                return node && !node[this.cascaderProps.children];
+              });
+
+              // 如果面板有选中项，使用面板的选中项；否则使用 selectedValues 构建
+              if (panelSelectedItems.length > 0) {
+                this.selectedItems = panelSelectedItems;
+              } else {
+                this.selectedItems = this.buildSelectedItemsFromValues();
+              }
+            }
+          } else {
+            // 面板不存在时，基于 selectedValues 构建
+            if (this.aggregationMode) {
+              // 聚合模式：使用聚合逻辑处理选中项
+              this.selectedItems = CascaderUtils.getAggregatedSelectedItems(this.selectedValues, this.filteredOptions, this.cascaderProps);
+            } else {
+              this.selectedItems = this.buildSelectedItemsFromValues();
+            }
+          }
+        }
+      });
+    },
+    // 基于 selectedValues 构建已选项列表
+    buildSelectedItemsFromValues() {
+      return CascaderUtils.buildSelectedItemsFromValues(this.selectedValues, this.filteredOptions, this.cascaderProps);
+    },
+    // 搜索处理
+    handleSearch() {
+      this.searchInput = this.searchInput.trim();
+      if (this.searchInput === '') {
+        this.isShowSearch = false;
+        return;
+      }
+      this.isShowSearch = false;
+      this.searchOptions = CascaderUtils.searchInTree(this.filteredOptions, this.searchInput, this.cascaderProps);
+
+      // 只设置搜索范围内的选中值
+      this.searchSelectedValues = CascaderUtils.getSearchSelectedValues(this.selectedValues, this.searchOptions, this.cascaderProps);
+      this.$nextTick(() => {
+        this.isShowSearch = true;
+        if (this.searchOptions.length > 0) {
+          // 等待搜索面板渲染完成后再展开
+          this.$nextTick(() => {
+            this.handleSearchExpand();
+          });
+        }
+      });
+    },
+    // 搜索模式下的展开处理
+    handleSearchExpand() {
+      if (this.$refs.searchCascaderPanel && this.searchOptions.length > 0) {
+        const panel = this.$refs.searchCascaderPanel;
+        const firstOption = this.searchOptions[0];
+
+        // 确保面板已经渲染
+        if (panel.menus && panel.menus[0]) {
+          // 找到第一个选项的节点
+          const targetNode = panel.menus[0].find(node => node.value == firstOption[this.cascaderProps.value]);
+          if (targetNode) {
+            // 展开第一个选项
+            panel.handleExpand(targetNode, true);
+            // 递归展开所有子节点
+            this.expandAllChildren(targetNode, panel);
+          }
+        }
+      }
+    },
+    // 展开变化处理
+    handleExpandChange(values = []) {
+      if (values.length === 1) {
+        this.$nextTick(() => {
+          const panel = this.$refs.cascaderPanel || this.$refs.searchCascaderPanel;
+          if (panel) {
+            const menus = panel.menus;
+            const targetNode = menus[0].find(node => node.value == values[0]);
+            if (targetNode) {
+              panel.handleExpand(targetNode, true);
+              this.expandAllChildren(targetNode, panel);
+            }
+          }
+        });
+      }
+    },
+    // 展开所有子节点
+    expandAllChildren(node, panel) {
+      if (node[this.cascaderProps.children] && node[this.cascaderProps.children].length > 0) {
+        const firstChild = node[this.cascaderProps.children][0];
+        panel.handleExpand(firstChild, true);
+        this.expandAllChildren(firstChild, panel);
+      }
+    },
+    // 值变化处理
+    handleValueChange() {
+      this.searchSelectedValues = [...this.selectedValues];
+      this.updateSelectedItems();
+
+      // 等待updateSelectedItems完成后再发出事件
+      this.$nextTick(() => {
+        this.isInternalUpdate = true; // 标记为内部更新
+        let emitValue = this.currentValue;
+
+        // 聚合模式下，发出聚合后的值
+        if (this.aggregationMode) {
+          emitValue = CascaderUtils.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0]; // 单选模式下返回单个值
+          }
+        }
+        this.$emit('input', emitValue);
+      });
+    },
+    // 搜索模式值变化处理
+    handleSearchValueChange(value) {
+      // 获取搜索面板中所有可能的叶子节点值
+      const searchLeafValues = CascaderUtils.getLeafValues(this.searchOptions, this.cascaderProps);
+      if (this.isMultiple) {
+        // 多选模式：从主选择列表中移除搜索范围内的项，然后添加搜索面板中选中的项
+        this.selectedValues = this.selectedValues.filter(path => {
+          const leafValue = path[path.length - 1];
+          return !searchLeafValues.includes(leafValue);
+        });
+        this.selectedValues = [...this.selectedValues, ...this.searchSelectedValues];
+      } else {
+        // 单选模式：直接替换为搜索面板中选中的项
+        if (value && value.length > 0) {
+          this.selectedValues = [value];
+        } else {
+          this.selectedValues = [];
+        }
+      }
+      this.isShow = false;
+      this.$nextTick(() => {
+        this.isShow = true;
+      });
+      this.updateSelectedItems();
+
+      // 等待updateSelectedItems完成后再发出事件
+      this.$nextTick(() => {
+        this.isInternalUpdate = true; // 标记为内部更新
+        let emitValue = this.currentValue;
+
+        // 聚合模式下，发出聚合后的值
+        if (this.aggregationMode) {
+          emitValue = CascaderUtils.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0]; // 单选模式下返回单个值
+          }
+        }
+        this.$emit('input', emitValue);
+      });
+    },
+    // 移除已选项
+    removeItem(item, index) {
+      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);
+
+      // 等待updateSelectedItems完成后再发出事件
+      this.$nextTick(() => {
+        this.isInternalUpdate = true; // 标记为内部更新
+        let emitValue = this.currentValue;
+
+        // 聚合模式下，发出聚合后的值
+        if (this.aggregationMode) {
+          emitValue = CascaderUtils.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0]; // 单选模式下返回单个值
+          }
+        }
+        this.$emit('input', emitValue);
+      });
+    },
+    // 全选/取消全选
+    handleSelectAll() {
+      if (!this.isMultiple) {
+        // 单选模式下不支持全选
+        return;
+      }
+      if (this.isAllSelected) {
+        this.selectedValues = [];
+        this.selectedItems = [];
+      } else {
+        const config = {
+          disabledField: this.disabledField,
+          disabledValue: this.disabledValue,
+          disabledCheck: this.disabledCheck
+        };
+        // 无论是普通模式还是聚合模式，全选时都选择所有可选的叶子节点
+        this.selectedValues = CascaderUtils.getAllLeafPaths(this.filteredOptions, config, this.cascaderProps);
+        this.updateSelectedItems();
+      }
+      // 等待updateSelectedItems完成后再发出事件
+      this.$nextTick(() => {
+        this.isInternalUpdate = true; // 标记为内部更新
+        let emitValue = this.currentValue;
+
+        // 聚合模式下，发出聚合后的值
+        if (this.aggregationMode) {
+          emitValue = CascaderUtils.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0]; // 单选模式下返回单个值
+          }
+        }
+        this.$emit('input', emitValue);
+      });
+    },
+    // 获取选中的数据
+    getSelectedData() {
+      let values = this.currentValue;
+      let valuesPath = this.selectedValues;
+
+      // 聚合模式下，返回聚合后的值和路径
+      if (this.aggregationMode) {
+        values = CascaderUtils.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+        valuesPath = CascaderUtils.getAggregatedSelectedPaths(this.selectedValues, this.filteredOptions, this.cascaderProps);
+        if (!this.isMultiple && values.length > 0) {
+          values = values[0]; // 单选模式下返回单个值
+        }
+      }
+      return {
+        valuesPath: valuesPath,
+        // 路径数组（聚合模式下已聚合）
+        values: values,
+        // 外部value（单选时返回单个值，多选时返回数组）
+        items: this.selectedItems,
+        count: this.selectedItems.length
+      };
+    },
+    // 清空选择
+    clearSelection() {
+      this.selectedValues = [];
+      this.selectedItems = [];
+      this.searchSelectedValues = [];
+      // 等待updateSelectedItems完成后再发出事件
+      this.$nextTick(() => {
+        this.isInternalUpdate = true; // 标记为内部更新
+        let emitValue = this.currentValue;
+
+        // 聚合模式下，发出聚合后的值
+        if (this.aggregationMode) {
+          emitValue = CascaderUtils.getAggregatedSelectedValues(this.selectedValues, this.filteredOptions, this.cascaderProps, this.parentNodePrefix);
+          if (!this.isMultiple && emitValue.length > 0) {
+            emitValue = emitValue[0]; // 单选模式下返回单个值
+          }
+        }
+        this.$emit('input', emitValue);
+      });
+    },
+    // 设置选择值
+    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 = CascaderUtils.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 = CascaderUtils.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;
+    }
+  }
+});
+;// ./src/components/cascader-panel/ByCascaderPanel.vue?vue&type=script&lang=js
+ /* harmony default export */ var cascader_panel_ByCascaderPanelvue_type_script_lang_js = (ByCascaderPanelvue_type_script_lang_js); 
+;// ./src/components/cascader-panel/ByCascaderPanel.vue
+
+
+
+
+
+/* normalize component */
+;
+var ByCascaderPanel_component = normalizeComponent(
+  cascader_panel_ByCascaderPanelvue_type_script_lang_js,
+  ByCascaderPanelvue_type_template_id_d3dd0512_render,
+  ByCascaderPanelvue_type_template_id_d3dd0512_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var ByCascaderPanel = (ByCascaderPanel_component.exports);
 ;// ./src/index.js
 
 
@@ -77537,6 +79008,7 @@ ByDialogService.install = function (Vue) {
 
 
 
+
 const components = {
   ByPager: pager,
   ByTable: table,
@@ -77550,7 +79022,8 @@ const components = {
   ByCommonSelector: ByCommonSelector,
   ByBatchQuerySelector: BatchQuerySelector,
   ByTreeSearch: ByTreeSearch,
-  ByDialog: ByDialog
+  ByDialog: ByDialog,
+  ByCascaderPanel: ByCascaderPanel
 };
 
 // 设置当前 z-index 起始值