@bytenew/bn-bus-ui 1.1.462 → 1.1.463

package/utils/addressParse.js

@@ -0,0 +1,735 @@
+let defaultData = []; //不包括省市级code的数据
+
+const mCity = {}; //以市为层级的数据 里面包括 p:省 c:市 a:区列表
+
+const mArea = {}; //以区为级别的数据 里面包括 p:省 c:市
+
+const mStreet = {}; //以街道为级别的数据 里面包括 c:市 a:区
+
+/**
+ * 处理原始地址数据转换成专用数据
+ * @param list  原始数据
+ * @param init  是否初始化 如传空 已转换过不会再次转换
+ * @returns {boolean}
+ */
+function parseArea(list, init) {
+  if (!init && defaultData.length) {
+    return true;
+  }
+  defaultData = list;
+  defaultData.forEach(province => {
+    if (province.city) {
+      province.city.forEach(city => {
+        if (city.name !== '其他') {
+          if (!mCity[city.name]) {
+            mCity[city.name] = [];
+          }
+          mCity[city.name].push({
+            p: province.name,
+            c: city.name,
+            a: city.area || [],
+            s: city.street || [],
+          });
+        }
+        if (city.area) {
+          city.area.forEach(area => {
+            if (area !== '其他') {
+              if (!mArea[area]) {
+                mArea[area] = [];
+              }
+              mArea[area].push({
+                p: province.name,
+                c: city.name
+              })
+            }
+            if (city.street && city.street[area]) {
+              city.street[area].forEach(street => {
+                if (street !== '其他') {
+                  if (!mStreet[street]) {
+                    mStreet[street] = [];
+                  }
+                  mStreet[street].push({
+                    c: city.name,
+                    a: area
+                  })
+                }
+              })
+            }
+          })
+        }
+      })
+    }
+  });
+}
+
+/**
+ * 解析地址详情（内部方法，需先调用 parseArea 初始化地址库）
+ * @param address 任意地址字符串
+ * @param sourceData 组件配置，如 extraInfo.isFourAddress
+ * @returns {{name: string, mobile: string, detail: string, zip_code: string, phone: string}}
+ */
+function parseAddressDetail(address, sourceData) {
+  const parse = {
+    name: '',
+    mobile: '',
+    detail: '',
+    zip_code: '',
+    phone: '',
+    extensionNumber:'',  // 淘宝分机号码
+  };
+  
+  // 第一步：预处理
+  address = joinAddressLines(address);
+  var presetName = address.name;
+  address = stripAddressLabels(address.text);
+  
+  // 清理特殊字符（包括句号）
+  const search = ['详细地址', '收货地址', '联系地址', '收件地址', '邮政编码', '手机号码', '联系电话', '联系方式', '收货人', '收件人', '联系人', '姓名', '名字', '手机号', '邮编', '收货', '地址', '详细', '电话', '固话', '：', ':', '；', ';', '，', ',', '。'];
+  search.forEach(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 = /([1][0-9]{10}((-[0-9]{4})?))|((86-?)?[1][0-9]{10})/g;
+  const mobile = mobileReg.exec(address);
+  if (mobile) {
+    parse.mobile = mobile[0];
+    address = address.replace(mobile[0], ' ');
+  }
+  
+  // 提取固话
+  const 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;
+  const phone = phoneReg.exec(address);
+  if (phone) {
+    //获取分机号码  例：16601795913-9385(11位手机号-xxxx)
+    var addressArry = address.split(' ');
+    var ext = addressArry.filter((item) => (item.length == 16 && item.indexOf('-')));
+    if(ext.length>0){
+      //截取分机号赋值
+      parse.extensionNumber = ext[0].split('-')[1];
+      //空格替换分机号
+      var extVal = '-'+parse.extensionNumber;
+      address = address.replace(extVal, ' ');
+    }
+    parse.phone = phone[0];
+    address = address.replace(phone[0], ' ');
+  }
+  
+  // 提取邮编
+  const zipReg = /([0-9]{6})/g;
+  const zip = zipReg.exec(address);
+  if (zip) {
+    parse.zip_code = zip[0];
+    address = address.replace(zip[0], '');
+  }
+  
+  // 清理多余空格
+  address = address.replace(/ {2,}/g, ' ').trim();
+  
+  // ============== 核心解析 ==============
+  let detail = detail_parse_forward(address, sourceData);
+  
+  console.log('正向解析结果:', JSON.stringify(detail));
+  
+  if (!detail.city) {
+    detail = detail_parse(address);
+    console.log('逆向解析结果:', JSON.stringify(detail));
+    
+    if (detail.area && !detail.city) {
+      detail = detail_parse(address, { ignoreArea: true });
+      console.log('ignoreArea解析结果:', JSON.stringify(detail));
+    }
+  }
+  
+  // 提取收件人姓名
+  if (detail.name) {
+    parse.name = detail.name;
+  } else {
+    // 从地址中提取可能的姓名
+    const addrParts = address.replace(detail.province || '', '').replace(detail.city || '', '').replace(detail.area || '', '').split(' ').filter(str => str.trim());
+    if (addrParts.length > 1) {
+      addrParts.forEach(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();
+      }
+    }
+  }
+  
+  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 === "新疆") {
+    parse.province = "新疆维吾尔自治区";
+  } else if (parse.province === "西藏") {
+    parse.province = "西藏自治区";
+  } else if (parse.province === "广西") {
+    parse.province = "广西壮族自治区";
+  } else if (parse.province === "宁夏") {
+    parse.province = "宁夏回族自治区";
+  } else if (parse.province === "内蒙古") {
+    parse.province = "内蒙古自治区";
+  }
+  console.log('最终解析结果:', JSON.stringify(parse));
+  return parse;
+}
+
+
+/**
+ * 正向解析模式
+ * 从前到后按 province city addr 逐级筛选
+ * 有city的值即可说明解析成功
+ * 此模式对地址顺序有要求
+ * 正向解析：省 -> area -> 反推城市
+ * @param address
+ * @returns {{province: string, city: string, area: string, addr: string}}
+ */
+function detail_parse_forward(address, sourceData) {
+  const parse = {
+    province: '',
+    city: '',
+    area: '',
+    street: '',
+    addr: address,
+    name: '',
+  };
+  
+  if (!address || address.length === 0) {
+    return parse;
+  }
+  
+  // ===== 关键修复：检查 defaultData 是否已初始化 =====
+  if (!defaultData || defaultData.length === 0) {
+    console.log('defaultData为空，请先调用parseArea初始化');
+    // 尝试使用 mArea 进行匹配
+    return parse;
+  }
+  
+  let remaining = address;
+  
+  // ========== 第一步：匹配省份 ==========
+  let matchedProvince = null;
+  
+  // 先检查地址是否以省份名开头
+  const provPatterns = [
+    { pattern: '广东省', province: '广东省' },
+    { pattern: '广东', province: '广东省' },
+    { pattern: '北京市', province: '北京市' },
+    { pattern: '北京', province: '北京市' },
+    { pattern: '天津市', province: '天津市' },
+    { pattern: '天津', province: '天津市' },
+    { pattern: '上海市', province: '上海市' },
+    { pattern: '上海', province: '上海市' },
+    { pattern: '重庆市', province: '重庆市' },
+    { pattern: '重庆', province: '重庆市' },
+  ];
+  
+  // 先尝试快速匹配
+  for (const pattern of provPatterns) {
+    if (remaining.startsWith(pattern.pattern)) {
+      // 在 defaultData 中找到对应的省份数据
+      const found = defaultData.find(p => 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);
+        break;
+      }
+    }
+  }
+  
+  // 如果快速匹配失败，遍历 defaultData
+  if (!matchedProvince) {
+    for (let i = 0; i < defaultData.length; i++) {
+      const province = defaultData[i];
+      const provName = province.name;
+      
+      // 查找省份名
+      let 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;
+      }
+      
+      // 查找简称
+      const 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 (!matchedProvince) {
+    console.log('未匹配到省份，defaultData前3个:', defaultData.slice(0, 3).map(p => p.name));
+    // 尝试通过 mArea 反查
+    const 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
+    let allAreas = [];
+    for (const city of matchedProvince.city) {
+      if (city.area && city.area.length > 0) {
+        for (const areaName of city.area) {
+          if (areaName && areaName !== '其他' && areaName !== '其它区' && areaName !== '其他区' && areaName.length >= 2) {
+            allAreas.push({
+              areaName: areaName,
+              cityName: city.name,
+              cityData: city
+            });
+          }
+        }
+      }
+    }
+    
+    // 按长度降序
+    allAreas.sort((a, b) => b.areaName.length - a.areaName.length);
+    
+    // 查找匹配的 area
+    for (const areaItem of allAreas) {
+      const idx = remaining.indexOf(areaItem.areaName);
+      if (idx > -1 && idx < 10) {
+        parse.city = areaItem.cityName;
+        parse.area = areaItem.areaName;
+        
+        let afterArea = remaining.substring(idx + areaItem.areaName.length);
+        
+        console.log('匹配到area:', areaItem.areaName, '城市:', areaItem.cityName);
+        
+        // 尝试匹配街道
+        if (areaItem.cityData.street && areaItem.cityData.street[areaItem.areaName]) {
+          const streets = areaItem.cityData.street[areaItem.areaName];
+          if (streets && streets.length > 0) {
+            const sortedStreets = streets
+              .filter(s => s && s !== '其他' && s !== '其它区' && s !== '其他区' && s.length >= 2)
+              .sort((a, b) => b.length - a.length);
+            
+            console.log('该area下的街道:', sortedStreets.slice(0, 5));
+            
+            for (const streetName of sortedStreets) {
+              // 完整匹配
+              let streetIdx = afterArea.indexOf(streetName);
+              if (streetIdx > -1 && streetIdx < 8) {
+                parse.street = streetName;
+                afterArea = afterArea.substring(streetIdx + streetName.length);
+                console.log('匹配到街道(完整):', streetName);
+                break;
+              }
+              
+              // 模糊匹配：去掉后缀
+              const 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;
+                }
+              }
+            }
+          }
+        }
+        
+        parse.addr = afterArea.trim();
+        return parse;
+      }
+    }
+    
+    console.log('未匹配到area，尝试直接匹配城市');
+    
+    // 如果没找到 area，尝试直接匹配城市名
+    for (const city of matchedProvince.city) {
+      const cityName = city.name;
+      const idx = remaining.indexOf(cityName);
+      if (idx > -1 && idx < 10) {
+        parse.city = cityName;
+        remaining = remaining.substring(idx + cityName.length);
+        
+        // 尝试在剩余部分找 area
+        if (city.area && city.area.length > 0) {
+          const sortedAreas = [...city.area]
+            .filter(a => a && a.length >= 2)
+            .sort((a, b) => b.length - a.length);
+          
+          for (const areaName of sortedAreas) {
+            const areaIdx = remaining.indexOf(areaName);
+            if (areaIdx > -1 && areaIdx < 10) {
+              parse.area = areaName;
+              remaining = remaining.substring(areaIdx + areaName.length);
+              break;
+            }
+          }
+        }
+        
+        parse.addr = remaining.trim();
+        return parse;
+      }
+    }
+  }
+  
+  parse.addr = remaining;
+  return parse;
+}
+
+/**
+ * 新增：通过 area 反查省份和城市（当正向匹配省份失败时使用）
+ */
+function findProvinceByArea(address) {
+  if (!mArea) return null;
+  
+  // 收集所有 area
+  let allAreas = [];
+  for (const areaName in mArea) {
+    if (areaName && areaName.length >= 2) {
+      const idx = address.indexOf(areaName);
+      if (idx > -1 && idx < 10) {
+        allAreas.push({
+          name: areaName,
+          index: idx,
+          data: mArea[areaName]
+        });
+      }
+    }
+  }
+  
+  // 按位置排序，取最早出现的
+  allAreas.sort((a, b) => a.index - b.index);
+  
+  if (allAreas.length > 0) {
+    const bestMatch = allAreas[0];
+    const 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;
+}
+
+/**
+ * 逆向解析 从后【县，区，旗】往前解析
+ * 有地区就能大概返回地址了
+ * @param address
+ * @param ignoreArea 是否忽视区 因为地址中含有区容易导致匹配错误 例：山东省蓬莱市黄海花园东区西门宝威学堂 曲荣声收15753572456
+ * @returns {{province: string, city: string, area: string, name: string, _area: string, addr: string}}
+ */
+function detail_parse(address, {ignoreArea = false} = {}) {
+  const parse = {
+    province: '',
+    city: '',
+    area: '',
+    name: '',
+    _area: '',
+    addr: address,
+  };
+  
+  if (!address || address.length === 0) {
+    return parse;
+  }
+  
+  address = address.replace(/ {2,}/g, ' ').trim();
+  
+  // 查找 area
+  if (!ignoreArea && mArea) {
+    let bestMatch = null;
+    
+    for (const areaName in mArea) {
+      if (!areaName || areaName === '其他' || areaName === '其它区' || areaName === '其他区' || areaName.length < 2) {
+        continue;
+      }
+      
+      const 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 (bestMatch) {
+      console.log('逆向匹配到area:', bestMatch.name, '位置:', bestMatch.index);
+      
+      parse.area = bestMatch.name;
+      parse.addr = address.substring(bestMatch.index + bestMatch.name.length).trim();
+      
+      const areaData = bestMatch.data;
+      
+      if (areaData.length === 1) {
+        parse.province = areaData[0].p;
+        parse.city = areaData[0].c;
+        console.log('逆向确定省市:', parse.province, parse.city);
+      } else {
+        console.log('该area有多个城市:', areaData.map(d => d.c));
+        
+        // 通过上下文判断
+        for (const candidate of areaData) {
+          if (address.includes(candidate.c)) {
+            parse.province = candidate.p;
+            parse.city = candidate.c;
+            break;
+          }
+        }
+        
+        if (!parse.city) {
+          for (const candidate of areaData) {
+            const cityShort = candidate.c.replace('市', '');
+            if (cityShort.length >= 2 && address.includes(cityShort)) {
+              parse.province = candidate.p;
+              parse.city = candidate.c;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  // 通过城市名匹配
+  if (!parse.city && mCity) {
+    for (const 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;
+      }
+    }
+  }
+  
+  return parse;
+}
+
+const MUNICIPALITIES = ['上海', '北京', '天津', '重庆'];
+
+/**
+ * 统一换行符格式
+ */
+function normalizeLineBreaks(address) {
+  return String(address || '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\r/g, '\n')
+    .replace(/\t/g, ' ');
+}
+
+/**
+ * 常见地址字段标签（姓名：、详细地址： 等），较长标签优先匹配
+ */
+var ADDRESS_LABEL_PATTERN = '(?:详细地址|收货地址|联系地址|收件地址|邮政编码|手机号码|联系电话|联系方式|收货人|收件人|联系人|姓名|名字|手机号|邮编|收货|地址|详细|固话|电话)[：:]';
+var ADDRESS_LABEL_REG = new RegExp(ADDRESS_LABEL_PATTERN, 'g');
+var ADDRESS_LABEL_TEST_REG = new RegExp(ADDRESS_LABEL_PATTERN);
+
+/**
+ * 去除「姓名：」「详细地址：」等字段标签前缀
+ */
+function stripAddressLabels(text) {
+  return String(text || '').replace(ADDRESS_LABEL_REG, ' ');
+}
+
+var NAME_LABELS = ['姓名', '名字', '联系人', '收货人', '收件人'];
+var PHONE_LABELS = ['电话', '手机号', '手机号码', '联系电话', '联系方式', '固话'];
+
+/**
+ * 解析「标签：值」格式的单行
+ */
+function matchLabeledLine(line) {
+  var match = line.match(/^([\u4e00-\u9fa5A-Za-z0-9]+)[：:]\s*(.+)$/);
+  if (!match) {
+    return null;
+  }
+  return { label: match[1], value: match[2].trim() };
+}
+
+/**
+ * 按换行符拆分段落，去除行内空白后用空格拼接为单行
+ * 若每行是「标签：值」格式，则按标签分类提取姓名、电话和地址
+ */
+function joinAddressLines(address) {
+  var normalized = normalizeLineBreaks(address);
+  var lines = normalized.split('\n').filter(function(line) {
+    return line.replace(/[ \t\f\v]+/g, ' ').trim();
+  });
+  if (lines.length === 1) {
+    var singleLine = lines[0].replace(/[ \t\f\v]+/g, ' ').trim();
+    if ((singleLine.match(/[：:]/g) || []).length > 1 && ADDRESS_LABEL_TEST_REG.test(singleLine)) {
+      return {
+        text: stripAddressLabels(singleLine).replace(/ {2,}/g, ' ').trim(),
+        name: '',
+        phoneHint: '',
+      };
+    }
+  }
+  var parts = [];
+  var extracted = { name: '', phoneHint: '' };
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].replace(/[ \t\f\v]+/g, ' ').trim();
+    if (!line) {
+      continue;
+    }
+    var labeled = matchLabeledLine(line);
+    if (labeled) {
+      if (NAME_LABELS.indexOf(labeled.label) > -1) {
+        extracted.name = labeled.value;
+      } else if (PHONE_LABELS.indexOf(labeled.label) > -1) {
+        extracted.phoneHint = labeled.value;
+      } else {
+        parts.push(labeled.value);
+      }
+    } else {
+      parts.push(line);
+    }
+  }
+  return {
+    text: parts.join(' '),
+    name: extracted.name,
+    phoneHint: extracted.phoneHint,
+  };
+}
+
+/**
+ * 从全局变量或 options 中获取 areaList（CDN 加载后挂载在 window.areaList）
+ * @param {object} options
+ * @param {array} [options.areaList] 地址库原始数据，不传则从全局 areaList 读取
+ * @returns {array|null}
+ */
+function getGlobalAreaList(options = {}) {
+  if (options.areaList) {
+    return options.areaList;
+  }
+  if (typeof window !== 'undefined' && window.areaList) {
+    return window.areaList;
+  }
+  try {
+    // CDN 场景下 areaList 为全局变量
+    // eslint-disable-next-line no-undef
+    if (typeof areaList !== 'undefined') {
+      // eslint-disable-next-line no-undef
+      return areaList;
+    }
+  } catch (e) {
+    // areaList 未定义时忽略
+  }
+  return null;
+}
+
+/**
+ * 判断直辖市名称在前 8 个字符中是否只出现一次（用于补全省份前缀）
+ */
+function checkMunicipalityChars(str, name) {
+  const prefix = str.substring(0, 8);
+  const firstIndex = prefix.indexOf(name);
+  const lastIndex = prefix.lastIndexOf(name);
+  return firstIndex !== -1 && firstIndex === lastIndex;
+}
+
+/**
+ * 预处理地址字符串：去空格，并为缺少省份前缀的直辖市地址补全
+ */
+function preprocessAddress(address) {
+  var cleanAddress = normalizeLineBreaks(address).replace(/[ \t\f\v]+/g, '');
+  cleanAddress = cleanAddress.replace(/\n+/g, '\n').replace(/^\n+|\n+$/g, '');
+  MUNICIPALITIES.forEach(function(name) {
+    if (cleanAddress.indexOf('\n') > -1) {
+      var lines = cleanAddress.split('\n');
+      for (var i = 0; i < lines.length; i++) {
+        if (checkMunicipalityChars(lines[i], name)) {
+          lines[i] = name + lines[i];
+        }
+      }
+      cleanAddress = lines.join('\n');
+    } else if (checkMunicipalityChars(cleanAddress, name)) {
+      cleanAddress = name + cleanAddress;
+    }
+  });
+  return cleanAddress;
+}
+
+/**
+ * 自动识别地址信息，格式化为省市区街道和收件人等信息
+ * @param {string} address 原始地址字符串（可含空格、姓名、手机号等）
+ * @param {object} [sourceData] 组件 sourceData，用于四级地址等配置（extraInfo.isFourAddress）
+ * @param {object} [options] 可选配置
+ * @param {array} [options.areaList] 地址库原始数据，默认从全局 areaList 获取
+ * @returns {{name: string, mobile: string, phone: string, zip_code: string, extensionNumber: string, province: string, city: string, area: string, street: string, addr: string, result: *}}
+ */
+export function addressParse(address, sourceData, options = {}) {
+  const list = getGlobalAreaList(options);
+  if (list) {
+    parseArea(list);
+  }
+  const cleanAddress = preprocessAddress(address);
+  return parseAddressDetail(cleanAddress, sourceData || {});
+}