@bytenew/bn-applet-ui 1.1.35 → 1.1.37

package/dist/bn-applet-ui.common.js

@@ -21556,6 +21556,15 @@ var es_array_sort = __webpack_require__(6910);
 
 
 
+
+
+
+
+
+
+
+
+
 
 
 
@@ -21645,24 +21654,34 @@ function parseAddressDetail(address, sourceData) {
     phone: '',
     extensionNumber: '' // 淘宝分机号码
   };
+
+  // 第一步：预处理
   address = joinAddressLines(address);
   var presetName = address.name;
   address = stripAddressLabels(address.text);
+
+  // 清理特殊字符（包括句号）
   var search = ['详细地址', '收货地址', '联系地址', '收件地址', '邮政编码', '手机号码', '联系电话', '联系方式', '收货人', '收件人', '联系人', '姓名', '名字', '手机号', '邮编', '收货', '地址', '详细', '电话', '固话', '：', ':', '；', ';', '，', ',', '。'];
   search.forEach(function (str) {
     address = address.replace(new RegExp(str, 'g'), ' ');
   });
+
+  // 替换多个空格为单个空格
   address = address.replace(/ {2,}/g, ' ');
+
+  // 处理电话号码格式
   address = address.replace(/(\d{3})-(\d{4})-(\d{4})/g, '$1$2$3');
   address = address.replace(/(\d{3}) (\d{4}) (\d{4})/g, '$1$2$3');
 
-  // const mobileReg = /(86-[1][0-9]{10})|(86[1][0-9]{10})|([1][0-9]{10})/g;
+  // 提取手机号
   var mobileReg = /([1][0-9]{10}((-[0-9]{4})?))|((86-?)?[1][0-9]{10})/g;
   var mobile = mobileReg.exec(address);
   if (mobile) {
     parse.mobile = mobile[0];
     address = address.replace(mobile[0], ' ');
   }
+
+  // 提取固话
   var phoneReg = /(([0-9]{3,4}-)[0-9]{7,8})|([0-9]{12})|([0-9]{11})|([0-9]{10})|([0-9]{9})|([0-9]{8})|([0-9]{7})/g;
   var phone = phoneReg.exec(address);
   if (phone) {
@@ -21681,71 +21700,67 @@ function parseAddressDetail(address, sourceData) {
     parse.phone = phone[0];
     address = address.replace(phone[0], ' ');
   }
+
+  // 提取邮编
   var zipReg = /([0-9]{6})/g;
   var zip = zipReg.exec(address);
   if (zip) {
     parse.zip_code = zip[0];
     address = address.replace(zip[0], '');
   }
-  address = address.replace(/ {2,}/, ' ');
-  var detail = detail_parse_forward(address.trim(), sourceData);
+
+  // 清理多余空格
+  address = address.replace(/ {2,}/g, ' ').trim();
+
+  // ============== 核心解析 ==============
+  var detail = detail_parse_forward(address, sourceData);
+  console.log('正向解析结果:', JSON.stringify(detail));
   if (!detail.city) {
-    detail = detail_parse(address.trim());
+    detail = detail_parse(address);
+    console.log('逆向解析结果:', JSON.stringify(detail));
     if (detail.area && !detail.city) {
-      detail = detail_parse(address.trim(), {
+      detail = detail_parse(address, {
         ignoreArea: true
       });
-      //   console.log('smart_parse->ignoreArea');
-    } else {
-      //   console.log('smart_parse');
+      console.log('ignoreArea解析结果:', JSON.stringify(detail));
     }
-    //这个待完善
-    var list = address.replace(detail.province, '').replace(detail.city, '').replace(detail.area, '').split(' ').filter(function (str) {
-      return str;
+  }
+
+  // 提取收件人姓名
+  if (detail.name) {
+    parse.name = detail.name;
+  } else {
+    // 从地址中提取可能的姓名
+    var addrParts = address.replace(detail.province || '', '').replace(detail.city || '', '').replace(detail.area || '', '').split(' ').filter(function (str) {
+      return str.trim();
     });
-    if (list.length > 1) {
-      list.forEach(function (str) {
+    if (addrParts.length > 1) {
+      addrParts.forEach(function (str) {
         if (!parse.name || str && str.length < parse.name.length) {
           parse.name = str.trim();
         }
       });
       if (parse.name) {
-        detail.addr = detail.addr.replace(parse.name, '').trim();
-      }
-    }
-  } else {
-    if (detail.name) {
-      parse.name = detail.name;
-    } else {
-      var _list = detail.addr.split(' ').filter(function (str) {
-        return str;
-      });
-      if (_list.length > 1) {
-        parse.name = _list[_list.length - 1];
-      }
-      //详细地址中去掉 姓名
-      if (parse.name) {
-        detail.addr = detail.addr.replace(parse.name, '').trim();
+        detail.addr = (detail.addr || '').replace(parse.name, '').trim();
       }
     }
-
-    //将分机号自动粘贴在收件人姓名后
-    if (parse.extensionNumber) {
-      parse.name = parse.name + '[转' + parse.extensionNumber + ']';
-    }
   }
-  parse.province = detail.province;
-  parse.city = detail.city;
-  parse.area = detail.area;
-  parse.street = detail.street;
-  parse.addr = detail.addr;
-  parse.result = detail.result;
+  if (parse.extensionNumber) {
+    parse.name = parse.name + '[转' + parse.extensionNumber + ']';
+  }
+  parse.province = detail.province || '';
+  parse.city = detail.city || '';
+  parse.area = detail.area || '';
+  parse.street = detail.street || '';
+  parse.addr = detail.addr || '';
   if (presetName) {
     parse.name = presetName;
     if (parse.addr) {
       parse.addr = parse.addr.replace(presetName, '').trim();
     }
   }
+
+  // 省份标准化
   if (parse.province === "澳门" || parse.province === "香港") {
     parse.province += "特别行政区";
   } else if (parse.province === "新疆") {
@@ -21758,14 +21773,8 @@ function parseAddressDetail(address, sourceData) {
     parse.province = "宁夏回族自治区";
   } else if (parse.province === "内蒙古") {
     parse.province = "内蒙古自治区";
-  } else {
-    if ("北京市上海市天津市重庆市".indexOf(parse.province) === -1) {
-      // parse.province += "省";
-    }
-  }
-  if (parse.city.indexOf("市") === -1) {
-    // parse.city += "市";
   }
+  console.log('最终解析结果:', JSON.stringify(parse));
   return parse;
 }
 
@@ -21774,6 +21783,7 @@ function parseAddressDetail(address, sourceData) {
  * 从前到后按 province city addr 逐级筛选
  * 有city的值即可说明解析成功
  * 此模式对地址顺序有要求
+ * 正向解析：省 -> area -> 反推城市
  * @param address
  * @returns {{province: string, city: string, area: string, addr: string}}
  */
@@ -21783,92 +21793,330 @@ function detail_parse_forward(address, sourceData) {
     city: '',
     area: '',
     street: '',
-    addr: '',
+    addr: address,
     name: ''
   };
-  var addressCopy = address;
-  var provinceKey = ['特别行政区', '古自治区', '维吾尔自治区', '壮族自治区', '回族自治区', '自治区', '省省直辖', '省', '市'];
-  var cityKey = ['布依族苗族自治州', '苗族侗族自治州', '自治州', '州', '市', '县'];
-  for (var i in defaultData) {
-    var province = defaultData[i];
-    var provinceSimple = province.name.replace('省', '');
-    var index = address.indexOf(province.name);
-    if (index == -1) {
-      if (address.indexOf(provinceSimple) > -1) {
-        // address= address.replace(provinceSimple,province.name);
-        index = address.indexOf(provinceSimple);
-      }
-    }
-    if (index > -1) {
-      if (index > 0) {
-        //省份不是在第一位，在省份之前的字段识别为名称
-        parse.name = address.substr(0, index).trim();
-      }
-      parse.province = province.name;
-      address = address.substr(index + provinceSimple.length);
-      for (var k in provinceKey) {
-        if (address.indexOf(provinceKey[k]) === 0) {
-          address = address.substr(provinceKey[k].length);
+  if (!address || address.length === 0) {
+    return parse;
+  }
+
+  // ===== 关键修复：检查 defaultData 是否已初始化 =====
+  if (!defaultData || defaultData.length === 0) {
+    console.log('defaultData为空，请先调用parseArea初始化');
+    // 尝试使用 mArea 进行匹配
+    return parse;
+  }
+  var remaining = address;
+
+  // ========== 第一步：匹配省份 ==========
+  var matchedProvince = null;
+
+  // 先检查地址是否以省份名开头
+  var provPatterns = [{
+    pattern: '广东省',
+    province: '广东省'
+  }, {
+    pattern: '广东',
+    province: '广东省'
+  }, {
+    pattern: '北京市',
+    province: '北京市'
+  }, {
+    pattern: '北京',
+    province: '北京市'
+  }, {
+    pattern: '天津市',
+    province: '天津市'
+  }, {
+    pattern: '天津',
+    province: '天津市'
+  }, {
+    pattern: '上海市',
+    province: '上海市'
+  }, {
+    pattern: '上海',
+    province: '上海市'
+  }, {
+    pattern: '重庆市',
+    province: '重庆市'
+  }, {
+    pattern: '重庆',
+    province: '重庆市'
+  }];
+
+  // 先尝试快速匹配
+  var _loop = function _loop() {
+    var pattern = _provPatterns[_i];
+    if (remaining.startsWith(pattern.pattern)) {
+      // 在 defaultData 中找到对应的省份数据
+      var found = defaultData.find(function (p) {
+        return p.name === pattern.province;
+      });
+      if (found) {
+        matchedProvince = found;
+        parse.province = pattern.province;
+        remaining = remaining.substring(pattern.pattern.length);
+        if (remaining.startsWith('省') && pattern.pattern !== pattern.province) {
+          remaining = remaining.substring(1);
         }
+        console.log('快速匹配到省份:', pattern.province);
+        return 1; // break
+      }
+    }
+  };
+  for (var _i = 0, _provPatterns = provPatterns; _i < _provPatterns.length; _i++) {
+    if (_loop()) break;
+  }
+
+  // 如果快速匹配失败，遍历 defaultData
+  if (!matchedProvince) {
+    for (var i = 0; i < defaultData.length; i++) {
+      var province = defaultData[i];
+      var provName = province.name;
+
+      // 查找省份名
+      var idx = remaining.indexOf(provName);
+      if (idx > -1 && idx < 5) {
+        if (idx > 0) {
+          parse.name = remaining.substring(0, idx).trim();
+        }
+        matchedProvince = province;
+        parse.province = provName;
+        remaining = remaining.substring(idx + provName.length);
+        console.log('遍历匹配到省份(全名):', provName, '剩余:', remaining);
+        break;
       }
-      for (var j in province.city) {
-        var city = province.city[j];
-        index = address.indexOf(city.name);
-        var citySimple = city.name.replace('市', '');
-        if (index == -1) {
-          if (address.indexOf(citySimple) > -1) {
-            // address= address.replace(citySimple,city.name);
-            index = address.indexOf(citySimple);
+
+      // 查找简称
+      var provShort = provName.replace('省', '').replace('市', '');
+      if (provShort !== provName && provShort.length >= 2) {
+        idx = remaining.indexOf(provShort);
+        if (idx > -1 && idx < 5) {
+          if (idx > 0) {
+            parse.name = remaining.substring(0, idx).trim();
+          }
+          matchedProvince = province;
+          parse.province = provName;
+          remaining = remaining.substring(idx + provShort.length);
+          if (remaining.startsWith('省')) {
+            remaining = remaining.substring(1);
           }
+          console.log('遍历匹配到省份(简称):', provName, '剩余:', remaining);
+          break;
         }
-        if (index > -1 && index < 3) {
-          parse.city = city.name;
-          address = address.substr(index + citySimple.length);
-          for (var _k in cityKey) {
-            if (address.indexOf(cityKey[_k]) === 0) {
-              address = address.substr(cityKey[_k].length);
+      }
+    }
+  }
+  if (!matchedProvince) {
+    console.log('未匹配到省份，defaultData前3个:', defaultData.slice(0, 3).map(function (p) {
+      return p.name;
+    }));
+    // 尝试通过 mArea 反查
+    var reverseResult = findProvinceByArea(remaining);
+    if (reverseResult) {
+      parse.province = reverseResult.province;
+      parse.city = reverseResult.city;
+      parse.area = reverseResult.area;
+      parse.addr = reverseResult.addr || remaining;
+      return parse;
+    }
+    return parse;
+  }
+
+  // ========== 第二步：在省份内查找 area，反推城市 ==========
+  if (matchedProvince.city && matchedProvince.city.length > 0) {
+    // 收集所有 area
+    var allAreas = [];
+    var _iterator = _createForOfIteratorHelper(matchedProvince.city),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var city = _step.value;
+        if (city.area && city.area.length > 0) {
+          var _iterator4 = _createForOfIteratorHelper(city.area),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var areaName = _step4.value;
+              if (areaName && areaName !== '其他' && areaName !== '其它区' && areaName !== '其他区' && areaName.length >= 2) {
+                allAreas.push({
+                  areaName: areaName,
+                  cityName: city.name,
+                  cityData: city
+                });
+              }
             }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
           }
-          if (city.area) {
-            // 对区域进行排序，优先匹配较长的区域名（如：临澧县优先于澧县）
-            var sortedAreas = _toConsumableArray(city.area).sort(function (a, b) {
+        }
+      }
+
+      // 按长度降序
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    allAreas.sort(function (a, b) {
+      return b.areaName.length - a.areaName.length;
+    });
+
+    // 查找匹配的 area
+    for (var _i2 = 0, _allAreas = allAreas; _i2 < _allAreas.length; _i2++) {
+      var areaItem = _allAreas[_i2];
+      var _idx = remaining.indexOf(areaItem.areaName);
+      if (_idx > -1 && _idx < 10) {
+        parse.city = areaItem.cityName;
+        parse.area = areaItem.areaName;
+        var afterArea = remaining.substring(_idx + areaItem.areaName.length);
+        console.log('匹配到area:', areaItem.areaName, '城市:', areaItem.cityName);
+
+        // 尝试匹配街道
+        if (areaItem.cityData.street && areaItem.cityData.street[areaItem.areaName]) {
+          var streets = areaItem.cityData.street[areaItem.areaName];
+          if (streets && streets.length > 0) {
+            var sortedStreets = streets.filter(function (s) {
+              return s && s !== '其他' && s !== '其它区' && s !== '其他区' && s.length >= 2;
+            }).sort(function (a, b) {
               return b.length - a.length;
             });
-            for (var _k2 in sortedAreas) {
-              var area = sortedAreas[_k2];
-              index = address.indexOf(area);
-              if (index > -1 && index < 3) {
-                parse.area = area;
-                address = address.substr(index + parse.area.length);
-                if (city.street && city.street[area] && sourceData && sourceData.extraInfo && sourceData.extraInfo.isFourAddress) {
-                  for (var m in city.street[area]) {
-                    var street = city.street[area][m];
-                    var indexStreet = address.indexOf(street);
-                    if (indexStreet > -1) {
-                      parse.street = street;
-                      address = address.substr(indexStreet + parse.street.length);
-                      break;
+            console.log('该area下的街道:', sortedStreets.slice(0, 5));
+            var _iterator2 = _createForOfIteratorHelper(sortedStreets),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var streetName = _step2.value;
+                // 完整匹配
+                var streetIdx = afterArea.indexOf(streetName);
+                if (streetIdx > -1 && streetIdx < 8) {
+                  parse.street = streetName;
+                  afterArea = afterArea.substring(streetIdx + streetName.length);
+                  console.log('匹配到街道(完整):', streetName);
+                  break;
+                }
+
+                // 模糊匹配：去掉后缀
+                var streetShort = streetName.replace('街道', '').replace('镇', '').replace('乡', '');
+                if (streetShort !== streetName && streetShort.length >= 2) {
+                  streetIdx = afterArea.indexOf(streetShort);
+                  if (streetIdx > -1 && streetIdx < 8) {
+                    parse.street = streetName;
+                    afterArea = afterArea.substring(streetIdx + streetShort.length);
+                    if (afterArea.startsWith('区')) {
+                      afterArea = afterArea.substring(1);
                     }
+                    console.log('匹配到街道(模糊):', streetShort, '->', streetName);
+                    break;
                   }
                 }
-                break;
               }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
             }
           }
-          break;
         }
+        parse.addr = afterArea.trim();
+        return parse;
       }
-      parse.addr = address.trim();
-      if (parse.city) {
-        break;
-      } else if (parse.province) {
-        address = addressCopy;
+    }
+    console.log('未匹配到area，尝试直接匹配城市');
+
+    // 如果没找到 area，尝试直接匹配城市名
+    var _iterator3 = _createForOfIteratorHelper(matchedProvince.city),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var _city = _step3.value;
+        var cityName = _city.name;
+        var _idx2 = remaining.indexOf(cityName);
+        if (_idx2 > -1 && _idx2 < 10) {
+          parse.city = cityName;
+          remaining = remaining.substring(_idx2 + cityName.length);
+
+          // 尝试在剩余部分找 area
+          if (_city.area && _city.area.length > 0) {
+            var sortedAreas = _toConsumableArray(_city.area).filter(function (a) {
+              return a && a.length >= 2;
+            }).sort(function (a, b) {
+              return b.length - a.length;
+            });
+            var _iterator5 = _createForOfIteratorHelper(sortedAreas),
+              _step5;
+            try {
+              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                var _areaName = _step5.value;
+                var areaIdx = remaining.indexOf(_areaName);
+                if (areaIdx > -1 && areaIdx < 10) {
+                  parse.area = _areaName;
+                  remaining = remaining.substring(areaIdx + _areaName.length);
+                  break;
+                }
+              }
+            } catch (err) {
+              _iterator5.e(err);
+            } finally {
+              _iterator5.f();
+            }
+          }
+          parse.addr = remaining.trim();
+          return parse;
+        }
       }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
     }
   }
+  parse.addr = remaining;
   return parse;
 }
 
+/**
+ * 新增：通过 area 反查省份和城市（当正向匹配省份失败时使用）
+ */
+function findProvinceByArea(address) {
+  if (!mArea) return null;
+
+  // 收集所有 area
+  var allAreas = [];
+  for (var areaName in mArea) {
+    if (areaName && areaName.length >= 2) {
+      var idx = address.indexOf(areaName);
+      if (idx > -1 && idx < 10) {
+        allAreas.push({
+          name: areaName,
+          index: idx,
+          data: mArea[areaName]
+        });
+      }
+    }
+  }
+
+  // 按位置排序，取最早出现的
+  allAreas.sort(function (a, b) {
+    return a.index - b.index;
+  });
+  if (allAreas.length > 0) {
+    var bestMatch = allAreas[0];
+    var areaData = bestMatch.data;
+    if (areaData && areaData.length >= 1) {
+      return {
+        province: areaData[0].p,
+        city: areaData[0].c,
+        area: bestMatch.name,
+        addr: address.substring(bestMatch.index + bestMatch.name.length)
+      };
+    }
+  }
+  return null;
+}
+
 /**
  * 逆向解析 从后【县，区，旗】往前解析
  * 有地区就能大概返回地址了
@@ -21886,162 +22134,96 @@ function detail_parse(address) {
     area: '',
     name: '',
     _area: '',
-    addr: ''
+    addr: address
   };
-  var areaIndex = -1,
-    cityIndex = -1;
-  address = address.replace('  ', ' ');
-  if (!ignoreArea && address.indexOf('县') > -1 || !ignoreArea && address.indexOf('区') > -1 || !ignoreArea && address.indexOf('旗') > -1) {
-    if (address.indexOf('旗') > -1) {
-      areaIndex = address.indexOf('旗');
-      parse.area = address.substr(areaIndex - 1, 2);
-    }
-    if (address.indexOf('区') > -1) {
-      // 改进区名识别逻辑，优先匹配地址库中存在的完整区名
-      areaIndex = address.indexOf('区');
-      if (address.lastIndexOf('市', areaIndex) > -1) {
-        cityIndex = address.lastIndexOf('市', areaIndex);
-        parse.area = address.substr(cityIndex + 1, areaIndex - cityIndex);
-      } else {
-        // 查找所有可能的区名，优先选择较长的匹配项
-        var possibleAreas = [];
-        // 从地址中寻找所有可能的区名
-        for (var areaName in mArea) {
-          if (address.includes(areaName) && areaName.endsWith('区')) {
-            var pos = address.indexOf(areaName);
-            if (pos !== -1 && pos <= areaIndex && pos >= Math.max(0, areaIndex - 6)) {
-              possibleAreas.push(areaName);
-            }
-          }
-        }
-        if (possibleAreas.length > 0) {
-          // 按长度降序排列，优先选择较长的匹配项
-          possibleAreas.sort(function (a, b) {
-            return b.length - a.length;
-          });
-          parse.area = possibleAreas[0];
-          areaIndex = address.lastIndexOf(parse.area);
-        } else {
-          parse.area = address.substr(areaIndex - 2, 3);
+  if (!address || address.length === 0) {
+    return parse;
+  }
+  address = address.replace(/ {2,}/g, ' ').trim();
+
+  // 查找 area
+  if (!ignoreArea && mArea) {
+    var bestMatch = null;
+    for (var areaName in mArea) {
+      if (!areaName || areaName === '其他' || areaName === '其它区' || areaName === '其他区' || areaName.length < 2) {
+        continue;
+      }
+      var idx = address.indexOf(areaName);
+      if (idx > -1) {
+        if (!bestMatch || idx < bestMatch.index || idx === bestMatch.index && areaName.length > bestMatch.name.length) {
+          bestMatch = {
+            name: areaName,
+            index: idx,
+            data: mArea[areaName]
+          };
         }
       }
     }
-    if (address.indexOf('县') > -1) {
-      // 改进县名识别逻辑，优先匹配地址库中存在的完整县名
-      areaIndex = address.lastIndexOf('县');
-      if (address.lastIndexOf('市', areaIndex) > -1) {
-        cityIndex = address.lastIndexOf('市', areaIndex);
-        parse.area = address.substr(cityIndex + 1, areaIndex - cityIndex);
+    if (bestMatch) {
+      console.log('逆向匹配到area:', bestMatch.name, '位置:', bestMatch.index);
+      parse.area = bestMatch.name;
+      parse.addr = address.substring(bestMatch.index + bestMatch.name.length).trim();
+      var areaData = bestMatch.data;
+      if (areaData.length === 1) {
+        parse.province = areaData[0].p;
+        parse.city = areaData[0].c;
+        console.log('逆向确定省市:', parse.province, parse.city);
       } else {
-        // 查找所有可能的县名，优先选择较长的匹配项
-        var _possibleAreas = [];
-        // 从地址中寻找所有可能的县名
-        for (var _areaName in mArea) {
-          if (address.includes(_areaName) && _areaName.endsWith('县')) {
-            var _pos = address.indexOf(_areaName);
-            if (_pos !== -1 && _pos <= areaIndex && _pos >= Math.max(0, areaIndex - 6)) {
-              _possibleAreas.push(_areaName);
+        console.log('该area有多个城市:', areaData.map(function (d) {
+          return d.c;
+        }));
+
+        // 通过上下文判断
+        var _iterator6 = _createForOfIteratorHelper(areaData),
+          _step6;
+        try {
+          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+            var _candidate = _step6.value;
+            if (address.includes(_candidate.c)) {
+              parse.province = _candidate.p;
+              parse.city = _candidate.c;
+              break;
             }
           }
+        } catch (err) {
+          _iterator6.e(err);
+        } finally {
+          _iterator6.f();
         }
-        if (_possibleAreas.length > 0) {
-          // 按长度降序排列，优先选择较长的匹配项
-          _possibleAreas.sort(function (a, b) {
-            return b.length - a.length;
-          });
-          parse.area = _possibleAreas[0];
-          areaIndex = address.lastIndexOf(parse.area);
-        } else {
-          parse.area = address.substr(areaIndex - 2, 3);
+        if (!parse.city) {
+          var _iterator7 = _createForOfIteratorHelper(areaData),
+            _step7;
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var candidate = _step7.value;
+              var cityShort = candidate.c.replace('市', '');
+              if (cityShort.length >= 2 && address.includes(cityShort)) {
+                parse.province = candidate.p;
+                parse.city = candidate.c;
+                break;
+              }
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
         }
       }
     }
-    parse.addr = address.substr(areaIndex + 1);
-  } else {
-    if (address.indexOf('市') > -1) {
-      areaIndex = address.indexOf('市');
-      parse.area = address.substr(areaIndex - 2, 3);
-      parse.addr = address.substr(areaIndex + 1);
-    } else {
-      parse.addr = address;
-    }
-  }
-  if (address.indexOf('市') > -1 || address.indexOf('盟') > -1 || address.indexOf('州') > -1) {
-    if (address.indexOf('市') > -1) {
-      parse._area = address.substr(address.indexOf('市') - 2, 2);
-    }
-    if (address.indexOf('盟') > -1 && !mCity[parse._area]) {
-      parse._area = address.substr(address.indexOf('盟') - 2, 2);
-    }
-    if (address.indexOf('州') > -1 && !mCity[parse._area]) {
-      parse._area = address.substr(address.indexOf('州') - 2, 2);
-    }
   }
-  parse.area = parse.area.trim();
-
-  // 确保选择最长的匹配项
-  if (parse.area && mArea[parse.area]) {
-    // 检查是否有更长的匹配项
-    var checkLongerMatch = function checkLongerMatch(currentArea, addressSubstring, endIndex) {
-      var longerMatch = currentArea;
-      // 检查在当前地址片段中是否存在更长的匹配项
-      for (var _areaName2 in mArea) {
-        if (addressSubstring.includes(_areaName2) && _areaName2.length > longerMatch.length && (_areaName2.endsWith('县') || _areaName2.endsWith('区') || _areaName2.endsWith('旗'))) {
-          var _pos2 = addressSubstring.lastIndexOf(_areaName2);
-          if (_pos2 !== -1 && _pos2 <= endIndex) {
-            longerMatch = _areaName2;
-          }
-        }
-      }
-      return longerMatch;
-    };
 
-    // 更新区域名称为最长匹配项
-    var originalArea = parse.area;
-    if (address) {
-      parse.area = checkLongerMatch(parse.area, address, areaIndex);
-      // 如果区域名称发生变化，更新areaIndex
-      if (parse.area !== originalArea) {
-        areaIndex = address.lastIndexOf(parse.area);
-      }
-    }
-    if (mArea[parse.area].length === 1) {
-      parse.province = mArea[parse.area][0].p;
-      parse.city = mArea[parse.area][0].c;
-    } else {
-      parse._area = parse._area.trim();
-      var addr = address.substr(0, areaIndex);
-      var d = mArea[parse.area].find(function (item) {
-        return item.p.indexOf(addr) > -1 || item.c === parse._area;
-      });
-      if (d) {
-        parse.province = d.p;
-        parse.city = d.c;
-      } else {
-        parse.result = mArea[parse.area];
-      }
-    }
-  } else {
-    if (parse._area) {
-      var city = mCity[parse._area];
-      if (city) {
-        parse.province = city[0].p;
-        parse.city = city[0].c;
-        parse.addr = address.substr(address.indexOf(parse.city) + parse.city.length + 1);
-        parse.area = '';
-        for (var i in city[0].a) {
-          if (parse.addr.indexOf(city[0].a[i]) === 0) {
-            parse.area = city[0].a[i];
-            parse.addr = parse.addr.replace(city[0].a[i], '');
-            break;
-          }
-        }
+  // 通过城市名匹配
+  if (!parse.city && mCity) {
+    for (var cityName in mCity) {
+      if (cityName && cityName.length >= 2 && address.includes(cityName)) {
+        parse.city = cityName;
+        parse.province = mCity[cityName][0].p;
+        console.log('通过城市名匹配:', parse.province, parse.city);
+        break;
       }
-    } else {
-      parse.area = '';
     }
   }
-  parse.addr = parse.addr.trim();
   return parse;
 }
 var MUNICIPALITIES = ['上海', '北京', '天津', '重庆'];
@@ -23638,13 +23820,13 @@ function formatColumnVal(component, values, power) {
           }
           // 级联组件关联其他组件查询选项
           if (data.extraInfo.relationColumns && values) {
-            var condition = {};
+            var extCondition = {};
             data.extraInfo.relationColumns.forEach(function (i) {
               if (values[i]) {
-                condition[i] = values[i].code;
+                extCondition[i] = values[i].code;
               }
             });
-            data.postData.condition = JSON.stringify(condition);
+            data.postData.extCondition = JSON.stringify(extCondition);
           }
           data.pathUrl = '/v2/project/column/select';
         }