bxs-tools-ui 3.3.2 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bxs-tools-ui",
-  "version": "3.3.2",
+  "version": "3.4.0",
   "description": "微易前端业务组件",
   "main": "lib/index.js",
   "module": "es/index.js",
@@ -15,6 +15,7 @@
     "docs": "npm run init && rollup -c rollup/rollup.prod.site.js",
     "dev": "npm run init && rollup -c rollup/rollup.dev.js -w",
     "build": "npm run init && rollup -c rollup/rollup.prod.js",
+    "analyze": "ANALYZE=1 npm run build",
     "test": "echo \"Error: no test specified\" && exit 1",
     "eslint:fix": "eslint --fix '{src,packages,docs}/**/*.{js,vue,ts}'",
     "prettier": "prettier --write '{src,packages}/**/*.{js,vue}'",
@@ -51,6 +52,7 @@
     "@babel/plugin-transform-runtime": "^7.28.0",
     "@babel/preset-env": "^7.16.0",
     "@babel/preset-typescript": "^7.10.4",
+    "@bxs/jax": "^1.23.0",
     "@commitlint/cli": "^19.3.0",
     "@commitlint/config-conventional": "^19.2.2",
     "@commitlint/parse": "^19.0.3",
@@ -97,6 +99,7 @@
     "rollup-plugin-postcss": "^4.0.2",
     "rollup-plugin-serve": "^3.0.0",
     "rollup-plugin-typescript2": "^0.36.0",
+    "rollup-plugin-visualizer": "^5.14.0",
     "rollup-plugin-vue": "^5.1.9",
     "selfsigned": "^2.4.1",
     "standard-version": "^9.5.0",
@@ -118,12 +121,11 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.27.6",
-    "@bxs/jax": "^1.23.0",
-    "bxs-ui-vue": "^4.2.1",
     "lodash": "^4.17.21",
     "qs": "^6.15.0"
   },
   "peerDependencies": {
+    "@bxs/jax": "^1.23.0",
     "vant": "^2.13.2",
     "vue": "2.6.14"
   },

package/packages/add-and-take/demo/index.vue

@@ -153,12 +153,10 @@ export default {
     getPlanbookData() {
       const self = this
       const { URL_PARAM } = self
-      const { planbookId, publicPbUuid, uuid } = URL_PARAM
+      const { planbookId, uuid } = URL_PARAM
       return getPlanbookData({
         insuranceTypeId: planbookId || 13767,
-        resultUuid: uuid,
-        publicPbUuid
-        // publicPbUuid: '5d6499946bbb47bb8f6a286e9d4eee77'
+        resultUuid: uuid
       })
         .then(async data => {
           await initPageData(data)
@@ -173,7 +171,7 @@ export default {
     },
     autoImportData() {
       const { URL_PARAM, exportData, inputData } = this
-      const { planbookId, publicPbUuid } = URL_PARAM
+      const { planbookId } = URL_PARAM
       if (inputData) {
         const gPromises = inputData.productGroupList
           .filter(g => g.prodOrderList)
@@ -182,7 +180,6 @@ export default {
               return doubleCalcProductData(inputData, {
                 planbookId: Number(planbookId) || 13767,
                 executeSource: exportData ? 'import' : 'init',
-                publicPbUuid,
                 groupKey: g.key,
                 productKey: p.key,
                 isIgnoreError: true

package/packages/adjust-baoe/index.vue

@@ -196,19 +196,12 @@ export default class AdjustBaoe extends Vue {
       return null
     }
     const adjustRecord = {}
-    insList.map((ins, idx, arr) => {
+    insList.map(ins => {
       const titleUi = ins.eleOrderList.find(e => e.key === 'title')
       if (!(ins.adjustBaoe && !ins.groupKey && titleUi && titleUi.value)) {
         return
       }
-      let groupChecked
-      if (ins.isGroup) {
-        groupChecked = arr.find(groupIns => {
-          const insuranceIdUi = ins.eleOrderList.find(e => e.key === 'insuranceId')
-          return insuranceIdUi && groupIns.key == insuranceIdUi.value
-        })
-      }
-      const adjustKey = `baoe_${(groupChecked || ins).code || (groupChecked || ins).key}`
+      const adjustKey = `baoe_${ins.code || ins.key}`
       const baoeUi = ins.eleOrderList.find(e => e.key === 'baoe')
       adjustRecord[adjustKey] = baoeUi && baoeUi.value ? baoeUi.value : 0
     })
@@ -246,32 +239,26 @@ export default class AdjustBaoe extends Vue {
         delete ins[ele]
       })
     })
-    return validateAdjustBaoe(
-      {
-        insuranceTypeId: params.planbookId * 1,
-        publicPbUuid: params.publicPbUuid,
-        personData: {
-          personOrderList: convertPersonData(
-            personData,
-            personData.personOrderList.map(p => p.key)
-          )
-        },
-        productGroupList: [
-          {
-            key: params.groupKey,
-            prodOrderList: [
-              {
-                ...cloneProductData,
-                adjustBaoeData: this.adjustBaoeData
-              }
-            ]
-          }
-        ]
+    return validateAdjustBaoe({
+      insuranceTypeId: params.planbookId * 1,
+      personData: {
+        personOrderList: convertPersonData(
+          personData,
+          personData.personOrderList.map(p => p.key)
+        )
       },
-      {
-        publicPbUuid: params.publicPbUuid
-      }
-    ).catch(err => {
+      productGroupList: [
+        {
+          key: params.groupKey,
+          prodOrderList: [
+            {
+              ...cloneProductData,
+              adjustBaoeData: this.adjustBaoeData
+            }
+          ]
+        }
+      ]
+    }).catch(err => {
       this.adjustBaoeData = cloneAdjustBaoeData
       if (err) {
         this.$toast(err)

package/packages/adjust-baoe/readme.md

@@ -114,7 +114,6 @@ export default {
 | `planbookId`   | 计划书 ID                                             | Number          |
 | `groupKey`     | 产品组的 key                                          | String / Number |
 | `productKey`   | 产品的 key                                            | Number          |
-| `publicPbUuid` | 公开计划书的 uuid；传入时调用 public 接口进行保额校验 | String          |
 
 ---
 

package/packages/bxs-utils/planbook/common.ts

@@ -290,6 +290,11 @@ export function getExpressionParamMap(personData: IPbPersons, product: IPbProduc
       insuranceList.forEach(item => {
         map[`i${item.key}`] = item
       })
+      insuranceList
+        .filter(item => item.groupKey && item.title && !item.isCheckbox)
+        .forEach(item => {
+          map[`i${item.groupKey}`] = item
+        })
     }
   }
 

package/packages/bxs-utils/planbook/insurance.ts

@@ -1,10 +1,24 @@
 import { convertEleOrderListToObj, converUnit10000 } from './common'
 
+export function getInsDeriveRequired(ins: IProdInsurance): boolean {
+  if (!ins) {
+    return false
+  }
+  const { required, deriveRequired, eleOrderList } = ins
+  if (deriveRequired !== undefined) {
+    return deriveRequired
+  }
+  const titleEle = (eleOrderList || []).find((e: IInsElement) => e.key === 'title')
+  const requiredTitle = !!(titleEle && titleEle.value && titleEle.isDisabled)
+  return required === undefined ? requiredTitle : !!required && requiredTitle
+}
+
 /**
  * **初始化险种数据**
  * - 补充一些显示文案
  * - 转换元素的选项字段
  * - 预设一些后面可能用到的字段，如追加领取、减保领取
+ * - 首次初始化：按 title 锁定勾选写入 deriveRequired（只写一次；承保规则改 title 不再更新）
  * @author Lizhao <lz@winbaoxian.com>
  * @date 2022-04-26
  * @param {IProdInsurance} insData 必传。险种数据（单个）
@@ -99,6 +113,11 @@ export function initInsuranceData(insData: IProdInsurance): void {
       }
     }
   })
+
+  // 只根据初始化时的 title 锁定勾选写一次 deriveRequired；已有值则不改（含 cloneDeep 后再 init）
+  if (insData.deriveRequired === undefined) {
+    insData.deriveRequired = getInsDeriveRequired(insData)
+  }
 }
 
 /**

package/packages/bxs-utils/planbook/person.ts

@@ -1,4 +1,5 @@
 import { consoleLogWhenEnable, convertEleOrderListToObj } from './common'
+import { getInsDeriveRequired } from './insurance'
 
 /**
  * **初始化人员数据**
@@ -284,10 +285,10 @@ export function getInsuredAgeRange(inputData: IPbInput, verifyData: any): any {
           return
         }
         // 产品中是否有必选险种
-        let hasRequiredIns = (<IProdInsurance[]>prod.mulInsOrderList).some(ins => !!ins.required)
+        let hasRequiredIns = (<IProdInsurance[]>prod.mulInsOrderList).some(ins => getInsDeriveRequired(ins))
         //无必选产品，根据所有产品的最小值，最大值确定；有必选产品, 根据必选产品的最小值，最大值确定
         //无必选险种，根据所有险种的最小值，最大值确定；如果有必选险种：根据必选险种的最小值，最大值确定
-        if ((!ins.huomian || ins.huomian === 'beiHuomian') && (!hasRequiredProd || prod.required) && (!hasRequiredIns || ins.required)) {
+        if ((!ins.huomian || ins.huomian === 'beiHuomian') && (!hasRequiredProd || prod.required) && (!hasRequiredIns || getInsDeriveRequired(ins))) {
           verifyData[prod.key][ins.key].forEach(condi => {
             let currentAgeRange = ageRange[`insuredInfo${condi.sex}`]
             ageRange[`insuredInfo${condi.sex}`] = [

package/packages/bxs-utils/planbook/product.ts

@@ -1,5 +1,5 @@
 import QS from 'qs'
-import { memoize, cloneDeep, findLastIndex } from 'lodash'
+import { memoize, cloneDeep } from 'lodash'
 import { getPlanbookInsuranceVerifyData } from '../../../src/api/planbook.js'
 import {
   consoleLogWhenEnable,
@@ -10,12 +10,14 @@ import {
   executeElementRule
 } from './common'
 import { convertPersonData } from './person'
-import { initInsuranceData, insuranceDataHandler, restrictElementsInInsurance } from './insurance'
+import { initInsuranceData, insuranceDataHandler, restrictElementsInInsurance, getInsDeriveRequired } from './insurance'
 
 /**
  * **初始化产品数据（单个）**
  * - 初始化调整保额数据
  * - 初始化险种数据
+ * - 非 isCheckbox 组合险：同组子险只保留一个选中
+ * - 险种排序：普通险在前，组合险按首个子险出现顺序排在后
  * @author Lizhao <lz@winbaoxian.com>
  * @date 2022-04-26
  * @param {IPbProduct} prodData 必传。产品数据（单个）
@@ -35,17 +37,60 @@ export function initProductData(prodData: IPbProduct): IPbProduct {
   prodData.mulInsOrderList.forEach((ins: IProdInsurance) => {
     initInsuranceData(ins)
   })
+  prodData.mulInsOrderList = normalizeGroupInsuranceList(prodData.mulInsOrderList)
   setCommonInfo(prodData)
   return prodData
 }
 
+/**
+ * 组合险初始化整理：
+ * - 非 isCheckbox：同组多个选中时只保留第一个
+ * - 排序：普通险在前，组合险按 groupKey 首次出现顺序排在后（组内相对序不变）
+ */
+function normalizeGroupInsuranceList(list: IProdInsurance[]): IProdInsurance[] {
+  const normals: IProdInsurance[] = []
+  const groupBuckets = new Map<string, IProdInsurance[]>()
+  const groupOrder: string[] = []
+
+  list.forEach(ins => {
+    if (!ins.groupKey) {
+      normals.push(ins)
+      return
+    }
+    const gk = String(ins.groupKey)
+    if (!groupBuckets.has(gk)) {
+      groupBuckets.set(gk, [])
+      groupOrder.push(gk)
+    }
+    groupBuckets.get(gk)!.push(ins)
+  })
+
+  groupOrder.forEach(gk => {
+    let hasChecked = false
+    const siblings = groupBuckets.get(gk) || []
+    siblings
+      .filter((s: IProdInsurance) => !s.isCheckbox)
+      .map(s => (s.eleOrderList || []).find(e => e.key === 'title'))
+      .filter((title): title is IInsElement => !!title)
+      .forEach(title => {
+        if (hasChecked) {
+          title.value = false
+        } else {
+          hasChecked = !!title.value
+        }
+      })
+  })
+
+  const groups = groupOrder.reduce((arr: IProdInsurance[], gk) => arr.concat(groupBuckets.get(gk) || []), [])
+  return normals.concat(groups)
+}
+
 /**
  * **处理产品数据（单个）**
  * - 提取通用信息
  * - 处理险种数据
  * - 根据被、投保人信息，处理险种状态。如：险种是否可选
  * - 根据校验条件解析产品状态。如：险种是否可选、重新获取元素（下拉框、单选框）的可选项
- * - 创建或更新组合险（多个险种组合成一个险种）
  * - 根据被、投保人信息，判断该产品是否可以显示
  * @author Lizhao <lz@winbaoxian.com>
  * @date 2022-04-26
@@ -57,24 +102,7 @@ export function initProductData(prodData: IPbProduct): IPbProduct {
  */
 export async function productDataHandler(prodData: IPbProduct, prodVerifyData: any, personData: IPbPersons, parmas?: any): Promise<IPbProduct> {
   if (prodData) {
-    const { eventTarget } = parmas || {}
     const productVerifyData: any = await getSingleInsurancesVerifyData(prodVerifyData, prodData, personData, parmas).catch(() => {})
-    // 组合险种特殊处理：当用户点击组合险种的子险种选项时，将其他子险种的标题设置为未选中状态
-    if (eventTarget) {
-      const { insuranceKey, elementKey } = eventTarget
-      if (insuranceKey && elementKey === 'insuranceId') {
-        const groupInsurance = (prodData.mulInsOrderList || []).find(ins => ins.key === insuranceKey)
-        const groupInsuranceIdEle = (groupInsurance?.eleOrderList || []).find(e => e.key === 'insuranceId')
-        const subInsurances = (prodData.mulInsOrderList || []).filter(ins => ins.groupKey === insuranceKey)
-        subInsurances.forEach(ins => {
-          const titleEle = (ins.eleOrderList || []).find(e => e.key === 'title')
-          if (titleEle && groupInsuranceIdEle && !Array.isArray(groupInsuranceIdEle.value)) {
-            titleEle.value = groupInsuranceIdEle.value === ins.key
-          }
-        })
-      }
-    }
-  
     const hasProduct = prodData.mulInsOrderList
     const hasVerifyData = productVerifyData && Object.keys(productVerifyData).length
     const hasPersonData = personData && personData.personOrderList
@@ -135,14 +163,7 @@ export async function productDataHandler(prodData: IPbProduct, prodVerifyData: a
                 : `${eleTitle.labelName}-${ins.key}: 费率不存在！`
             )
           } else {
-            // 存在费率，险种可选
-            eleTitle.isDisabled = false
-            // 如果是必选险种，险种一定选中
-            if (ins.required && (!ins.groupKey || ins.isCheckbox)) {
-              eleTitle.value = true
-              eleTitle.isDisabled = true
-              consoleLogWhenEnable(`${eleTitle.labelName}-${ins.key}: 费率存在，险种为必选险且(为非组合险或为多选一险种)`)
-            }
+            eleTitle.isDisabled = getInsDeriveRequired(ins)
           }
           if (!curCondition) {
             break
@@ -274,7 +295,6 @@ export async function productDataHandler(prodData: IPbProduct, prodVerifyData: a
         }
       })
     }
-    setGroupInsurance(prodData)
     isHideProduct(prodData, productVerifyData, personOrderList)
   }
   return prodData
@@ -363,9 +383,6 @@ function getSingleInsurancesVerifyData(verifyData: any, prodData: IPbProduct, pe
       }
     }
     const insuranceIdList = prodData?.mulInsOrderList?.map(ins => ins.key).filter((k: any) => !['common'].includes(k))
-    prodData?.mulInsOrderList?.reduce((list: any, ins: IProdInsurance) => {
-      return ins.key === 'common' || ins.isGroup ? list : list.concat(ins.key)
-    }, [])
     return getAndCacheInsurancesVerifyData({
       pbId,
       productId,
@@ -467,113 +484,6 @@ export function setCommonInfo(prodData: IPbProduct): IPbProduct {
   return prodData
 }
 
-/**
- * **创建或更新组合险**
- * - 组合险是虚拟的险种，是为了解决特殊场景：多个险种，只能同时选中一个。
- * - 组合险的初始状态取决于子险种，状态包括：是否可选、包含的元素、元素的选项及值。用户有交互，以交互后的状态为准。
- * @ignore
- * @author Lizhao <lz@winbaoxian.com>
- * @date 2022-04-26
- * @param {IPbProduct} prodData 必传。产品数据（单个）
- * @returns {IPbProduct} 产品数据（单个）
- */
-export function setGroupInsurance(prodData: IPbProduct): IPbProduct {
-  const mulInsOrderList = (prodData && prodData.mulInsOrderList ? prodData.mulInsOrderList : []) as IProdInsurance[]
-  // 清空险种列表中的已有的险种组合
-  prodData.mulInsOrderList = mulInsOrderList.filter(ins => !ins.isGroup)
-
-  // 多险种选一，或多险种选多。生成一个组合，如多个险种合成豁免险
-  const groupInsuranceList = mulInsOrderList.filter(ins => !!ins.groupKey)
-  if (groupInsuranceList.length) {
-    const newGroupInsMap = {}
-    groupInsuranceList
-      .filter(ins => ins.groupKey)
-      .forEach(ins => {
-        newGroupInsMap[ins.groupKey!] = newGroupInsMap[ins.groupKey!] || {
-          key: ins.groupKey,
-          name: ins.groupName,
-          huomian: ins.huomian,
-          isGroup: true,
-          eleOrderList: [
-            {
-              key: 'title',
-              value: false,
-              isDisabled: false,
-              componentName: 'cmCommonTitle',
-              labelName: ins.groupName
-            },
-            {
-              key: 'insuranceId',
-              value: ins.isCheckbox ? [] : null,
-              componentName: ins.isCheckbox ? 'cmCommonCheckbox' : 'cmCommonRadio',
-              opts: []
-            }
-          ]
-        }
-
-        // 将子险种转换成险种组合的选项
-        const titleEle = (<IInsElement[]>ins.eleOrderList).find(e => e.key === 'title') as IInsElement
-        const insuranceIdEle = newGroupInsMap[ins.groupKey!].eleOrderList.find(e => e.key === 'insuranceId')
-        insuranceIdEle.opts.push({
-          val: ins.key,
-          code: ins.code,
-          desc: titleEle.labelName,
-          isDisabled: titleEle.isDisabled
-        })
-      })
-
-    // 处理组合险中的逻辑，并加入到产品险种列表中
-    for (let k in newGroupInsMap) {
-      const oldGroupInsurance = mulInsOrderList.find(ins => ins.key === k)
-      const oldGroupTitleElement = oldGroupInsurance ? oldGroupInsurance.eleOrderList?.find(e => e.key === 'title') : null
-      const oldGroupTitleValue = oldGroupTitleElement ? oldGroupTitleElement.value : null
-      const nGroupTitleEle = newGroupInsMap[k].eleOrderList.find(e => e.key === 'title')
-      const nGroupInsuranceIdEle = newGroupInsMap[k].eleOrderList.find(e => e.key === 'insuranceId')
-      const groupInsList = mulInsOrderList.filter((ins: IProdInsurance) => ins.groupKey == k)
-      if (nGroupTitleEle && nGroupInsuranceIdEle && groupInsList.length) {
-        const notDisabledInsurances: any[] = groupInsList.filter(ins => {
-          const titleEle = (ins.eleOrderList || []).find(e => e.key === 'title')
-          return titleEle && !titleEle.isDisabled
-        })
-        const checkedInsurances = notDisabledInsurances.filter(ins => {
-          const titleEle = (ins.eleOrderList || []).find(ele => ele.key === 'title')
-          return titleEle && titleEle.value
-        })
-        const hasRequiredIns = notDisabledInsurances.some(ins => ins.required)
-        const checkedInsurance = checkedInsurances[0]
-        // hasRequiredIns：如果组合险中有一款是必选的，则整个组合险为选中状态
-        // 所有险种都不可选，则组合险不可修改且不选中。否则，组合险种可选
-        nGroupTitleEle.value = oldGroupTitleValue === false ? oldGroupTitleValue : oldGroupTitleValue || !!checkedInsurance
-        if (hasRequiredIns) {
-          nGroupTitleEle.value = hasRequiredIns
-        }
-        nGroupTitleEle.isDisabled = hasRequiredIns || (nGroupInsuranceIdEle.opts || []).every(opt => !!opt.isDisabled)
-        nGroupInsuranceIdEle.value = checkedInsurance ? checkedInsurance.key : null
-
-        //将当前选中险种的部分数据复制到组合险中
-        if (checkedInsurance) {
-          // 定义组件险中的元素：自身eleOrderList + 所选险种的eleOrderList（不包含标题）
-          const keys = ['code', 'groupKey', 'groupName', 'isFollowing', 'key', 'name', 'accountData', 'reduceBaofData', 'duplicateReduceBaofData']
-          for (let ck in checkedInsurance) {
-            if (!keys.includes(ck)) {
-              if (ck === 'eleOrderList') {
-                newGroupInsMap[k][ck] = newGroupInsMap[k][ck].concat((<IInsElement[]>checkedInsurance[ck]).filter(ele => ele.key !== 'title'))
-              } else {
-                newGroupInsMap[k][ck] = checkedInsurance[ck]
-              }
-            }
-          }
-        }
-      }
-      const index = findLastIndex(mulInsOrderList, ins => ins.groupKey === k)
-      if (index >= 0) {
-        prodData.mulInsOrderList.splice(index + 1, 0, newGroupInsMap[k])
-      }
-    }
-  }
-  return prodData
-}
-
 /**
  * **判断是否隐藏产品**
  * - 根据必选险种，或者所有险种的年龄范围，取并集，计算出产品年龄范围
@@ -591,13 +501,13 @@ export function isHideProduct(prodData: IPbProduct, prodVerifyData: any, personO
   if (prodData && prodVerifyData && Object.keys(prodVerifyData).length && personOrderList) {
     if (prodData.mulInsOrderList) {
       // 产品中是否有必选险种且有费率
-      let hasRequiredIns = prodData.mulInsOrderList.some(ins => !!ins.required && prodVerifyData[ins.key])
+      let hasRequiredIns = prodData.mulInsOrderList.some(ins => getInsDeriveRequired(ins) && prodVerifyData[ins.key])
       prodData.mulInsOrderList.forEach(ins => {
         // 当前险种的限制条件
         let insuranceVerifyData = prodVerifyData[ins.key]
         if (insuranceVerifyData) {
           // 产品年龄范围取各险种最大范围
-          if ((!ins.huomian || ins.huomian == 'beiHuomian') && (!hasRequiredIns || (hasRequiredIns && ins.required))) {
+          if ((!ins.huomian || ins.huomian == 'beiHuomian') && (!hasRequiredIns || (hasRequiredIns && getInsDeriveRequired(ins)))) {
             insuranceVerifyData.forEach(verify => {
               ageRangeProd[verify.sex] = ageRangeProd[verify.sex] || []
               ageRangeProd[verify.sex] = [
@@ -830,8 +740,8 @@ export function restrictInsurancesInProduct({
 /**
  * **转换产品数据**
  * - 转换通用信息的数据
- * - 转换组合险的数据
- * - 转换常规险种的数据。包括将 eleOrderList 数组下的 value 值，转换成 key-value 键值对
+ * - 转换常规险种的数据（含组合险子险种）。包括将 eleOrderList 数组下的 value 值，转换成 key-value 键值对
+ * - 仅输出 title 为真的真实险种；组合险 UI 状态不进入本转换
  * @author Lizhao <lz@winbaoxian.com>
  * @date 2022-04-26
  * @param {IPbProduct} prodData 必传。产品数据（单个）
@@ -856,27 +766,10 @@ export function convertProductData(prodData: IPbProduct): IPbProduct {
       productData.common = insuranceData
       return
     }
-    if (insuranceData.title && !insuranceData.groupKey) {
-      if (insuranceData.isGroup) {
-        //组合险，则遍历其所选中的险种，并转换数据
-        const insuranceId = Array.isArray(insuranceData.insuranceId) ? insuranceData.insuranceId : [insuranceData.insuranceId]
-        insuranceId.forEach(insId => {
-          const checkedIns = (<IProdInsurance[]>prodData.mulInsOrderList).find(p => p.key === insId)
-          if (checkedIns) {
-            // 转换组合险中选中的险种
-            const checkedInsData = convertEleOrderListToObj(checkedIns)
-            insurance.eleOrderList &&
-              insurance.eleOrderList.forEach(function(ele) {
-                if (!['title', 'insuranceId'].includes(ele.key)) {
-                  checkedInsData[ele.key] = insuranceData[ele.key]
-                }
-              });
-            (<IProdInsurance[]>productData.mulInsOrderList).push(cloneDeep(checkedInsData))
-          }
-        })
-        return
-      }
-      (<IProdInsurance[]>productData.mulInsOrderList).push(insuranceData)
+    if (insuranceData.title) {
+      delete (insuranceData as any).deriveRequired
+      const mulInsOrderList = productData.mulInsOrderList as IProdInsurance[]
+      mulInsOrderList.push(insuranceData)
     }
   })
   return productData

package/packages/bxs-utils/readme.md

@@ -308,6 +308,8 @@ textOverflowEllipsis('hello world', 4); // returns 'hello world'
 
 - 初始化调整保额数据
 - 初始化险种数据
+- 非 `isCheckbox` 组合险：同组子险只保留一个选中
+- 险种排序：普通险在前，组合险按首个子险出现顺序排在后（组内相对序不变）
 
 **参数**
 
@@ -329,7 +331,6 @@ textOverflowEllipsis('hello world', 4); // returns 'hello world'
 - 处理险种数据
 - 根据被、投保人信息处理险种状态（如：险种是否可选）
 - 根据校验条件解析产品状态（如：重新获取元素的可选项）
-- 创建或更新组合险
 - 判断产品是否隐藏
 
 **参数**
@@ -390,6 +391,7 @@ textOverflowEllipsis('hello world', 4); // returns 'hello world'
 - 补充显示文案（保额、保费等字段的占位符）
 - 转换元素的选项字段（`optConf` → `opts`，补全 `isHide`、`isDisabled`、`isInvalid`）
 - 预设后续可能用到的字段，如追加领取、减保领取数据结构
+- 首次初始化时，按 title 锁定勾选写入 `deriveRequired`（只写一次；**仅**人员/产品年龄范围逻辑使用，不用于组合险 UI）
 
 **参数**
 

package/packages/index.ts

@@ -50,6 +50,6 @@ export {
 }
 
 export default {
-  version: '3.3.2',
+  version: '3.4.0',
   install
 }

package/packages/insure-calculate/demo/index.vue

@@ -29,7 +29,7 @@ Vue.use(Vant)
   }
 })
 export default class InsureCalculateDemo extends Vue {
-  productId: number | string = 110019 // 104367 100585 104733 102805 104931 110019;
+  productId: number | string = 103647 // 104367 100585 104733 102805 104931 110019;
   uuid = ''
   planParams = {
     detail_age: '',

package/packages/insure-calculate/index.vue

@@ -147,8 +147,8 @@
       </slot>
     </div>
 
-    <!-- bxs组件：职业列表，异步 查询使用，无检验规则 -->
-    <bxs-profession-list v-model="isShowProfession" :async-columns-params="asyncColumnsParams" readonly :prevent-scroll-through="true" />
+    <!-- 职业列表：异步查询，无检验规则 -->
+    <bxt-profession-list v-model="isShowProfession" :async-columns-params="asyncColumnsParams" readonly />
 
     <van-popup v-model="pickerConfig.visible" round position="bottom" get-container="body">
       <van-picker
@@ -186,9 +186,7 @@ import { Toast } from 'vant'
 import { get as _get } from 'lodash'
 import { parseTime } from '../../src/js/utils.js'
 import { getCommonCurrentUser, getAddress } from '../../src/api'
-import 'bxs-ui-vue/lib/index.css'
-import { ProfessionList } from 'bxs-ui-vue'
-import 'bxs-ui-vue/esm/profession-list/index.css'
+import ProfessionList from 'src/components/profession-list'
 
 import { insureCalculate, hasPlanParams } from 'packages/bxs-utils/index'
 import './index.less'
@@ -239,7 +237,7 @@ function initDatePickerConfig() {
 
 @Component({
   components: {
-    [ProfessionList.name]: ProfessionList
+    BxtProfessionList: ProfessionList
   }
 })
 export default class InsureCalculate extends Vue {
@@ -344,11 +342,13 @@ export default class InsureCalculate extends Vue {
     vm.setIsDevelop()
     if (!vm.uuid) {
       try {
+        // request 默认返回 res.data，即用户对象本身（含 uuid），不是 { data: { uuid } }
         const userInfo = await getCommonCurrentUser()
-        if (userInfo && userInfo.data && userInfo.data.uuid) {
-          vm.uuidFromApi = userInfo.data.uuid
+        const uuid = _get(userInfo, 'uuid') || _get(userInfo, 'data.uuid')
+        if (uuid) {
+          vm.uuidFromApi = uuid
         } else {
-          Toast(userInfo && userInfo.info ? userInfo.info : '')
+          Toast(_get(userInfo, 'info') || _get(userInfo, 'message') || '用户信息获取失败')
         }
       } catch (error) {
         Toast(error && error.info ? error.info : '用户信息获取失败')
@@ -357,17 +357,18 @@ export default class InsureCalculate extends Vue {
     vm.init()
   }
   init() {
-    const urlParamsProfess = {
-      userUuid: this.getU()
-    }
+    const userUuid = this.getU()
     const postParamsProfess = {
       productId: this.productId
     }
-    // 职业数据配置
-    this.asyncColumnsParams = {}
-    this.$set(this.asyncColumnsParams, 'urlParams', urlParamsProfess)
-    this.$set(this.asyncColumnsParams, 'postParams', postParamsProfess)
-    this.$set(this.asyncColumnsParams, 'isDev', this.isDevelop)
+    // 无 userUuid 时不传异步参数，避免 prop validator 告警；职业查询前需有登录态
+    this.asyncColumnsParams = userUuid
+      ? {
+          urlParams: { userUuid },
+          postParams: postParamsProfess,
+          isDev: this.isDevelop
+        }
+      : null
     let originData
     this.hasCalculateData = !!(this.calculateData && this.calculateData.current_data && this.calculateData.current_data.length)
     if (this.hasCalculateData) {