@pisell/pisellos 2.3.74 → 2.3.76

package/lib/modules/Payment/walletpass.js

@@ -1,68 +1,47 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/modules/Payment/walletpass.ts
-var walletpass_exports = {};
-__export(walletpass_exports, {
-  WalletPassPaymentImpl: () => WalletPassPaymentImpl
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(walletpass_exports);
-var import_types = require("./types");
-var import_utils = require("./utils");
-var WALLET_PAYMENT_ASSET_TAGS = /* @__PURE__ */ new Set([
-  "product_voucher",
-  "gift_card",
-  "point_card"
-]);
+exports.WalletPassPaymentImpl = void 0;
+var _types = require("./types");
+var _utils = require("./utils");
+const WALLET_PAYMENT_ASSET_TAGS = new Set(['product_voucher', 'gift_card', 'point_card']);
 function isWalletPaymentAsset(asset) {
-  return WALLET_PAYMENT_ASSET_TAGS.has(
-    String((asset == null ? void 0 : asset.tag) || "").toLowerCase()
-  );
+  return WALLET_PAYMENT_ASSET_TAGS.has(String(asset?.tag || '').toLowerCase());
 }
 function getWalletAssetId(asset) {
-  return (asset == null ? void 0 : asset.id) ?? (asset == null ? void 0 : asset.voucher_id) ?? (asset == null ? void 0 : asset.code);
+  return asset?.id ?? asset?.voucher_id ?? asset?.code;
 }
 function getWalletAssetKey(assetOrId) {
-  const id = assetOrId && typeof assetOrId === "object" ? getWalletAssetId(assetOrId) : assetOrId;
-  return id === void 0 || id === null ? "" : String(id);
+  const id = assetOrId && typeof assetOrId === 'object' ? getWalletAssetId(assetOrId) : assetOrId;
+  return id === undefined || id === null ? '' : String(id);
 }
 function matchesWalletAssetCode(asset, normalizedCode) {
-  return [asset == null ? void 0 : asset.code, asset == null ? void 0 : asset.encoded].some(
-    (identifier) => String(identifier ?? "").trim() === normalizedCode
-  );
+  return [asset?.code, asset?.encoded].some(identifier => String(identifier ?? '').trim() === normalizedCode);
 }
 function normalizeWalletAssetCode(code) {
-  return String(code ?? "").trim().toUpperCase();
+  return String(code ?? '').trim().toUpperCase();
 }
 function getWalletAssetCodeKeys(asset) {
-  return [asset == null ? void 0 : asset.code, asset == null ? void 0 : asset.encoded].map(normalizeWalletAssetCode).filter(Boolean);
+  return [asset?.code, asset?.encoded].map(normalizeWalletAssetCode).filter(Boolean);
 }
+
+/**
+ * 保存货币类扫码资产自身的可用余额，供后续前端策略重新计算。
+ * 搜索接口的 recommended_usage_amount 已扣除了搜索时的已选券，不能作为
+ * 取消勾选后的永久上限。积分卡的 balance_par_value 是积分值，不能直接
+ * 当作货币金额，因此继续沿用接口推荐金额。
+ */
 function withWalletAssetRecalculationBaseAmount(asset) {
-  const existingBaseAmount = Number(
-    asset == null ? void 0 : asset._wallet_asset_recalculation_base_amount
-  );
+  const existingBaseAmount = Number(asset?._wallet_asset_recalculation_base_amount);
   if (Number.isFinite(existingBaseAmount) && existingBaseAmount >= 0) {
     return asset;
   }
-  if (!["product_voucher", "gift_card"].includes(asset == null ? void 0 : asset.tag)) {
+  if (!['product_voucher', 'gift_card'].includes(asset?.tag)) {
     return asset;
   }
-  const balanceParValue = Number(asset == null ? void 0 : asset.balance_par_value);
+  const balanceParValue = Number(asset?.balance_par_value);
   if (!Number.isFinite(balanceParValue) || balanceParValue < 0) {
     return asset;
   }
@@ -72,32 +51,29 @@ function withWalletAssetRecalculationBaseAmount(asset) {
   };
 }
 function isWalletAssetAvailable(asset) {
-  if (!asset)
-    return false;
-  if (asset.unified_available_status !== void 0 && Number(asset.unified_available_status) !== 1) {
+  if (!asset) return false;
+  if (asset.unified_available_status !== undefined && Number(asset.unified_available_status) !== 1) {
     return false;
   }
-  if (asset._unified_available_status !== void 0 && Number(asset._unified_available_status) !== 1) {
+  if (asset._unified_available_status !== undefined && Number(asset._unified_available_status) !== 1) {
     return false;
   }
-  if (asset.available === false || asset.isDisabled === true)
-    return false;
+  if (asset.available === false || asset.isDisabled === true) return false;
   return true;
 }
 function getWalletAssetDeductionAmount(asset) {
-  const value = (asset == null ? void 0 : asset.actualDeduction) ?? (asset == null ? void 0 : asset._available_max_amount) ?? (asset == null ? void 0 : asset.edit_current_amount) ?? (asset == null ? void 0 : asset.recommended_usage_amount) ?? (asset == null ? void 0 : asset.available_max_amount) ?? (asset == null ? void 0 : asset.amount) ?? 0;
+  const value = asset?.actualDeduction ?? asset?._available_max_amount ?? asset?.edit_current_amount ?? asset?.recommended_usage_amount ?? asset?.available_max_amount ?? asset?.amount ?? 0;
   const amount = Number(value);
   return Number.isFinite(amount) && amount > 0 ? amount : 0;
 }
 function mergeWalletAssets(...groups) {
   const merged = [];
-  const indexByKey = /* @__PURE__ */ new Map();
-  groups.flat().forEach((asset) => {
+  const indexByKey = new Map();
+  groups.flat().forEach(asset => {
     const key = getWalletAssetKey(asset);
-    if (!key)
-      return;
+    if (!key) return;
     const existedIndex = indexByKey.get(key);
-    if (existedIndex === void 0) {
+    if (existedIndex === undefined) {
       indexByKey.set(key, merged.length);
       merged.push(asset);
       return;
@@ -109,19 +85,19 @@ function mergeWalletAssets(...groups) {
   });
   return merged;
 }
+
+/**
+ * 聚合接口不保证 recalculate_list 顺序；派生抵扣额依赖选择顺序，
+ * 因此已选资产必须先恢复为 selectedIds 的顺序再进入策略计算。
+ */
 function orderWalletAssetsByIds(assets, orderedIds) {
-  const assetByKey = new Map(
-    assets.map((asset) => [getWalletAssetKey(asset), asset])
-  );
-  const orderedKeys = new Set(orderedIds.map((id) => String(id)));
-  return [
-    ...orderedIds.map((id) => assetByKey.get(String(id))).filter((asset) => asset !== void 0),
-    ...assets.filter((asset) => !orderedKeys.has(getWalletAssetKey(asset)))
-  ];
+  const assetByKey = new Map(assets.map(asset => [getWalletAssetKey(asset), asset]));
+  const orderedKeys = new Set(orderedIds.map(id => String(id)));
+  return [...orderedIds.map(id => assetByKey.get(String(id))).filter(asset => asset !== undefined), ...assets.filter(asset => !orderedKeys.has(getWalletAssetKey(asset)))];
 }
 function createInitialWalletAssetsState() {
   return {
-    status: "idle",
+    status: 'idle',
     items: [],
     selectedIds: [],
     selectedItems: [],
@@ -132,45 +108,50 @@ function createInitialWalletAssetsState() {
     revision: 0
   };
 }
-var WalletPassPaymentImpl = class {
+
+/**
+ * 钱包支付实现
+ */
+class WalletPassPaymentImpl {
+  walletRecommendList = [];
+  userIdentificationCodes = [];
+  searchResults = [];
+  walletParams = null;
+  walletInitData = null;
+  walletAssetsState = createInitialWalletAssetsState();
+  walletAssetsRequestSequence = 0;
+  walletAssetsBehavior = {
+    autoSelectAfterSearch: true
+  };
+  pendingAutoSelectSearchCodes = new Set();
+  walletAssetsCalculationContext = {
+    orderTotalAmount: 0,
+    products: []
+  };
   constructor(paymentModule) {
     this.paymentModule = paymentModule;
-    this.walletRecommendList = [];
-    this.userIdentificationCodes = [];
-    this.searchResults = [];
-    this.walletParams = null;
-    this.walletInitData = null;
-    this.walletAssetsState = createInitialWalletAssetsState();
-    this.walletAssetsRequestSequence = 0;
-    this.walletAssetsBehavior = {
-      autoSelectAfterSearch: true
-    };
-    this.pendingAutoSelectSearchCodes = /* @__PURE__ */ new Set();
-    this.walletAssetsCalculationContext = {
-      orderTotalAmount: 0,
-      products: []
-    };
   }
   configureWalletAssetsBehavior(options) {
-    if (options.autoSelectAfterSearch === void 0)
-      return;
+    if (options.autoSelectAfterSearch === undefined) return;
     this.walletAssetsBehavior.autoSelectAfterSearch = options.autoSelectAfterSearch;
     if (!options.autoSelectAfterSearch) {
       this.pendingAutoSelectSearchCodes.clear();
     }
   }
+
   /**
    * 发送事件的辅助方法
    * 支持使用WalletPassHooks或PaymentHooks
    */
   emitEvent(hook, data) {
     try {
-      const eventName = hook.split(":")[1] || hook.replace(/^[A-Z][a-z]+/, "").replace(/^On/, "").toLowerCase();
+      // 提取事件名称，去掉模块前缀
+      const eventName = hook.split(':')[1] || hook.replace(/^[A-Z][a-z]+/, '').replace(/^On/, '').toLowerCase();
       const fullEventName = `${this.paymentModule.name}:${eventName}`;
       this.paymentModule.core.effects.emit(fullEventName, data);
     } catch (error) {
-      this.paymentModule.logError("[WalletPass] 发送事件失败", error, {
-        hook
+      this.paymentModule.logError('[WalletPass] 发送事件失败', error, {
+        hook: hook
       });
     }
   }
@@ -178,71 +159,48 @@ var WalletPassPaymentImpl = class {
     this.walletAssetsState = {
       ...this.walletAssetsState,
       ...patch,
-      items: [...patch.items ?? this.walletAssetsState.items],
-      selectedIds: [
-        ...patch.selectedIds ?? this.walletAssetsState.selectedIds
-      ],
-      selectedItems: [
-        ...patch.selectedItems ?? this.walletAssetsState.selectedItems
-      ],
-      committedIds: [
-        ...patch.committedIds ?? this.walletAssetsState.committedIds
-      ],
+      items: [...(patch.items ?? this.walletAssetsState.items)],
+      selectedIds: [...(patch.selectedIds ?? this.walletAssetsState.selectedIds)],
+      selectedItems: [...(patch.selectedItems ?? this.walletAssetsState.selectedItems)],
+      committedIds: [...(patch.committedIds ?? this.walletAssetsState.committedIds)],
       selectionSources: {
-        ...patch.selectionSources ?? this.walletAssetsState.selectionSources
+        ...(patch.selectionSources ?? this.walletAssetsState.selectionSources)
       },
       revision: this.walletAssetsState.revision + 1
     };
     const state = this.getWalletAssetsState();
-    this.emitEvent(import_types.WalletPassHooks.OnWalletAssetsStateChanged, { state });
+    this.emitEvent(_types.WalletPassHooks.OnWalletAssetsStateChanged, {
+      state
+    });
     return state;
   }
   recalculateWalletAssets(items, requestedIds, selectionSources) {
-    var _a, _b;
-    const committedKeys = new Set(
-      this.walletAssetsState.committedIds.map((id) => String(id))
-    );
-    const itemsByKey = new Map(
-      items.map((item) => [getWalletAssetKey(item), item])
-    );
-    const requested = requestedIds.map((id) => String(id)).filter((id) => !committedKeys.has(id)).map((id) => itemsByKey.get(id)).filter((item) => item && isWalletAssetAvailable(item));
+    const committedKeys = new Set(this.walletAssetsState.committedIds.map(id => String(id)));
+    const itemsByKey = new Map(items.map(item => [getWalletAssetKey(item), item]));
+    const requested = requestedIds.map(id => String(id)).filter(id => !committedKeys.has(id)).map(id => itemsByKey.get(id)).filter(item => item && isWalletAssetAvailable(item));
     let nextItems = items;
     let selectedItems = requested;
-    const evaluator = (_b = (_a = this.paymentModule.window) == null ? void 0 : _a.getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
-    if (evaluator == null ? void 0 : evaluator.recalculateVouchers) {
+    const evaluator = this.paymentModule.window?.getWalletPassEvaluator?.();
+    if (evaluator?.recalculateVouchers) {
       try {
-        const result = evaluator.recalculateVouchers(
-          items,
-          requested,
-          this.walletAssetsCalculationContext.orderTotalAmount,
-          this.walletAssetsCalculationContext.products
-        );
-        nextItems = mergeWalletAssets(items, (result == null ? void 0 : result.allWithUpdatedStatus) || []);
-        selectedItems = ((result == null ? void 0 : result.selectedWithDetails) || []).filter(
-          (item) => isWalletAssetAvailable(item) && getWalletAssetDeductionAmount(item) > 0
-        );
+        const result = evaluator.recalculateVouchers(items, requested, this.walletAssetsCalculationContext.orderTotalAmount, this.walletAssetsCalculationContext.products);
+        nextItems = mergeWalletAssets(items, result?.allWithUpdatedStatus || []);
+        selectedItems = (result?.selectedWithDetails || []).filter(item => isWalletAssetAvailable(item) && getWalletAssetDeductionAmount(item) > 0);
       } catch (error) {
-        this.paymentModule.logWarning(
-          "[WalletPass] 共享钱包资产重新计算失败，回退接口可用状态",
-          {
-            error: error instanceof Error ? error.message : String(error)
-          }
-        );
+        this.paymentModule.logWarning('[WalletPass] 共享钱包资产重新计算失败，回退接口可用状态', {
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
     }
-    const selectedIds = selectedItems.map((item) => getWalletAssetId(item)).filter((id) => id !== void 0 && id !== null);
-    const selectedKeys = new Set(selectedIds.map((id) => String(id)));
+    const selectedIds = selectedItems.map(item => getWalletAssetId(item)).filter(id => id !== undefined && id !== null);
+    const selectedKeys = new Set(selectedIds.map(id => String(id)));
     const nextSources = Object.entries(selectionSources).reduce((result, [key, source]) => {
-      if (selectedKeys.has(key))
-        result[key] = source;
+      if (selectedKeys.has(key)) result[key] = source;
       return result;
     }, {});
-    const totalSelectedAmount = selectedItems.reduce(
-      (total, item) => total + getWalletAssetDeductionAmount(item),
-      0
-    );
+    const totalSelectedAmount = selectedItems.reduce((total, item) => total + getWalletAssetDeductionAmount(item), 0);
     return this.publishWalletAssetsState({
-      status: "ready",
+      status: 'ready',
       items: nextItems,
       selectedIds,
       selectedItems,
@@ -251,25 +209,19 @@ var WalletPassPaymentImpl = class {
       error: null
     });
   }
+
   /**
    * 搜索接口只返回后端 Wallet Pass 数据，不包含前端策略 config。
    * 在资产进入共享选择状态前补齐策略结果，避免增量重算回退到接口状态。
    */
   formatSearchedWalletPaymentAssets(assets) {
-    var _a, _b, _c, _d;
-    if (!assets.length)
-      return assets;
-    const assetsWithRecalculationBase = assets.map(
-      withWalletAssetRecalculationBaseAmount
-    );
-    const evaluator = (_b = (_a = this.paymentModule.window) == null ? void 0 : _a.getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
-    if (!(evaluator == null ? void 0 : evaluator.searchVoucherFormat))
-      return assetsWithRecalculationBase;
+    if (!assets.length) return assets;
+    const assetsWithRecalculationBase = assets.map(withWalletAssetRecalculationBaseAmount);
+    const evaluator = this.paymentModule.window?.getWalletPassEvaluator?.();
+    if (!evaluator?.searchVoucherFormat) return assetsWithRecalculationBase;
     const hasCalculationProducts = this.walletAssetsCalculationContext.products.length > 0;
-    const products = hasCalculationProducts ? this.walletAssetsCalculationContext.products : ((_c = this.walletParams) == null ? void 0 : _c.products) || [];
-    const orderTotalAmount = Number(
-      hasCalculationProducts ? this.walletAssetsCalculationContext.orderTotalAmount : ((_d = this.walletParams) == null ? void 0 : _d.order_wait_pay_amount) || 0
-    );
+    const products = hasCalculationProducts ? this.walletAssetsCalculationContext.products : this.walletParams?.products || [];
+    const orderTotalAmount = Number(hasCalculationProducts ? this.walletAssetsCalculationContext.orderTotalAmount : this.walletParams?.order_wait_pay_amount || 0);
     try {
       const formattedAssets = evaluator.searchVoucherFormat({
         orderTotalAmount,
@@ -278,98 +230,74 @@ var WalletPassPaymentImpl = class {
       });
       return formattedAssets;
     } catch (error) {
-      this.paymentModule.logWarning(
-        "[WalletPass] 搜索资产策略格式化失败，保留接口结果",
-        {
-          error: error instanceof Error ? error.message : String(error)
-        }
-      );
+      this.paymentModule.logWarning('[WalletPass] 搜索资产策略格式化失败，保留接口结果', {
+        error: error instanceof Error ? error.message : String(error)
+      });
       return assetsWithRecalculationBase;
     }
   }
+
   /** 获取当前缓存中所有支付类 Wallet 资产的扫码 code。 */
   getSearchedWalletAssetCodes() {
     const cachedAssets = this.searchResults.filter(isWalletPaymentAsset);
-    const seenCodes = /* @__PURE__ */ new Set();
-    return cachedAssets.map((item) => String((item == null ? void 0 : item.code) || "").trim()).filter((code) => {
+    const seenCodes = new Set();
+    return cachedAssets.map(item => String(item?.code || '').trim()).filter(code => {
       const normalizedCode = code.toUpperCase();
-      if (!normalizedCode || seenCodes.has(normalizedCode))
-        return false;
+      if (!normalizedCode || seenCodes.has(normalizedCode)) return false;
       seenCodes.add(normalizedCode);
       return true;
     });
   }
+
   /**
    * 用订单重算接口返回的数据更新扫码 Wallet 缓存。
    * 接口暂时缺失某个扫码 code 时继续保留旧值，避免列表闪空。
    */
   syncSearchedWalletAssets(refreshedCandidates) {
     const cachedAssets = this.searchResults.filter(isWalletPaymentAsset);
-    const searchedCodeKeys = new Set(
-      this.getSearchedWalletAssetCodes().map((code) => code.toUpperCase())
-    );
-    if (searchedCodeKeys.size === 0)
-      return cachedAssets;
-    const cachedAssetByCode = /* @__PURE__ */ new Map();
-    cachedAssets.forEach((item) => {
-      getWalletAssetCodeKeys(item).forEach((code) => {
+    const searchedCodeKeys = new Set(this.getSearchedWalletAssetCodes().map(code => code.toUpperCase()));
+    if (searchedCodeKeys.size === 0) return cachedAssets;
+    const cachedAssetByCode = new Map();
+    cachedAssets.forEach(item => {
+      getWalletAssetCodeKeys(item).forEach(code => {
         cachedAssetByCode.set(code, item);
       });
     });
-    const refreshedAssets = refreshedCandidates.filter(
-      (item) => isWalletPaymentAsset(item) && searchedCodeKeys.has(
-        String((item == null ? void 0 : item.code) || "").trim().toUpperCase()
-      )
-    ).map((item) => {
-      const cachedAsset = getWalletAssetCodeKeys(item).map((code) => cachedAssetByCode.get(code)).find(Boolean);
+    const refreshedAssets = refreshedCandidates.filter(item => isWalletPaymentAsset(item) && searchedCodeKeys.has(String(item?.code || '').trim().toUpperCase())).map(item => {
+      const cachedAsset = getWalletAssetCodeKeys(item).map(code => cachedAssetByCode.get(code)).find(Boolean);
       return withWalletAssetRecalculationBaseAmount({
         ...cachedAsset,
         ...item
       });
     });
     if (refreshedAssets.length > 0) {
-      const replacedCodes = new Set(
-        refreshedAssets.map(
-          (item) => String((item == null ? void 0 : item.code) || "").trim().toUpperCase()
-        )
-      );
-      this.searchResults = [
-        ...this.searchResults.filter(
-          (item) => !replacedCodes.has(String((item == null ? void 0 : item.code) || "").trim().toUpperCase())
-        ),
-        ...refreshedAssets
-      ];
+      const replacedCodes = new Set(refreshedAssets.map(item => String(item?.code || '').trim().toUpperCase()));
+      this.searchResults = [...this.searchResults.filter(item => !replacedCodes.has(String(item?.code || '').trim().toUpperCase())), ...refreshedAssets];
     }
-    return mergeWalletAssets(
-      cachedAssets,
-      refreshedAssets
-    );
+    return mergeWalletAssets(cachedAssets, refreshedAssets);
   }
   isPendingAutoSelectAsset(asset) {
-    return getWalletAssetCodeKeys(asset).some(
-      (code) => this.pendingAutoSelectSearchCodes.has(code)
-    );
+    return getWalletAssetCodeKeys(asset).some(code => this.pendingAutoSelectSearchCodes.has(code));
   }
   clearPendingAutoSelectForAsset(asset) {
-    getWalletAssetCodeKeys(asset).forEach((code) => {
+    getWalletAssetCodeKeys(asset).forEach(code => {
       this.pendingAutoSelectSearchCodes.delete(code);
     });
   }
   queuePendingAutoSelectForAssets(assets) {
-    if (!this.walletAssetsBehavior.autoSelectAfterSearch)
-      return;
-    assets.forEach((asset) => {
-      getWalletAssetCodeKeys(asset).forEach((code) => {
+    if (!this.walletAssetsBehavior.autoSelectAfterSearch) return;
+    assets.forEach(asset => {
+      getWalletAssetCodeKeys(asset).forEach(code => {
         this.pendingAutoSelectSearchCodes.add(code);
       });
     });
   }
+
   /**
    * 生成钱包API默认参数
    * 根据业务数据生成标准的钱包API参数，并存储在模块中
    */
   generateWalletParams(businessData) {
-    var _a, _b;
     const {
       customer_id,
       holder,
@@ -379,36 +307,42 @@ var WalletPassPaymentImpl = class {
       payment_order_id,
       is_price_include_tax
     } = businessData;
+
+    // 转换金额为数字类型
     const totalAmount = Number(amountInfo.totalAmount);
     const subTotal = Number(amountInfo.subTotal);
     const walletParams = {
       is_price_include_tax,
-      sale_channel: "pos",
+      sale_channel: 'pos',
       customer_id: customer_id || 0,
       // 提供默认值，确保类型为 number
-      holder_id: ((_a = holder == null ? void 0 : holder.form_record) == null ? void 0 : _a[0]) || void 0,
+      holder_id: holder?.form_record?.[0] || undefined,
       order_expect_amount: totalAmount,
       // 订单小计金额
       order_product_amount: subTotal,
       // 订单待支付金额
-      order_wait_pay_amount: order_wait_pay_amount ?? ((amountInfo == null ? void 0 : amountInfo.isDeposit) ? Number(amountInfo == null ? void 0 : amountInfo.depositAmount) : totalAmount),
+      order_wait_pay_amount: order_wait_pay_amount ?? (amountInfo?.isDeposit ? Number(amountInfo?.depositAmount) : totalAmount),
       // order_behavior_count_customer_id: 1,
       products,
       prepare_payments: [],
       payment_order_id
     };
+
+    // 扫码可能早于异步 Wallet 初始化完成。walletParams 与前端增量重算
+    // 必须使用同一份当前购物车上下文，避免搜索按真实金额判断可用，
+    // 随后的 recalculateVouchers 却仍读取初始的 0 元/空商品上下文。
     this.walletParams = walletParams;
     this.walletAssetsCalculationContext = {
       orderTotalAmount: Number(walletParams.order_wait_pay_amount || 0),
       products: Array.isArray(walletParams.products) ? walletParams.products : []
     };
-    this.paymentModule.logInfo("[WalletPass] 钱包默认参数已生成并存储", {
+    this.paymentModule.logInfo('[WalletPass] 钱包默认参数已生成并存储', {
       customer_id: walletParams.customer_id,
       holder_id: walletParams.holder_id,
       order_expect_amount: walletParams.order_expect_amount,
       order_product_amount: walletParams.order_product_amount,
       order_wait_pay_amount: walletParams.order_wait_pay_amount,
-      products_count: ((_b = walletParams.products) == null ? void 0 : _b.length) || 0
+      products_count: walletParams.products?.length || 0
     });
     this.walletInitData = {
       transformList: [],
@@ -417,6 +351,7 @@ var WalletPassPaymentImpl = class {
     };
     return walletParams;
   }
+
   /**
    * 获取已存储的钱包参数
    * 返回之前生成并存储的钱包参数
@@ -424,23 +359,24 @@ var WalletPassPaymentImpl = class {
   getStoredWalletParams() {
     return this.walletParams;
   }
+
   /**
    * 清理已存储的钱包参数
    * 清除之前存储的钱包参数
    */
   clearStoredWalletParams() {
     this.walletParams = null;
-    this.paymentModule.logInfo("[WalletPass] 已存储的钱包参数已清理");
+    this.paymentModule.logInfo('[WalletPass] 已存储的钱包参数已清理');
   }
+
   /**
    * 从业务数据初始化钱包数据
    * 内部生成参数，然后调用标准的初始化流程
    */
   async initializeWalletDataFromBusinessAsync(businessData) {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
     const startTime = Date.now();
     const walletParams = this.generateWalletParams(businessData);
-    if (Number(((_a = businessData == null ? void 0 : businessData.amountInfo) == null ? void 0 : _a.totalAmount) || 0) < 0 || Number(((_b = businessData == null ? void 0 : businessData.amountInfo) == null ? void 0 : _b.subTotal) || 0) < 0) {
+    if (Number(businessData?.amountInfo?.totalAmount || 0) < 0 || Number(businessData?.amountInfo?.subTotal || 0) < 0) {
       return {
         walletRecommendList: [],
         userIdentificationCodes: [],
@@ -449,28 +385,36 @@ var WalletPassPaymentImpl = class {
         products: []
       };
     }
-    if ([1, 0].includes((walletParams == null ? void 0 : walletParams.customer_id) || 0)) {
+    if ([1, 0].includes(walletParams?.customer_id || 0)) {
       return {
         walletRecommendList: [],
         userIdentificationCodes: []
       };
     }
-    this.emitEvent(import_types.WalletPassHooks.OnWalletInitializationStarted, {
+
+    // 发送初始化开始事件
+    this.emitEvent(_types.WalletPassHooks.OnWalletInitializationStarted, {
       businessData,
       startTime
     });
-    this.paymentModule.logInfo("[WalletPass] 开始从业务数据初始化钱包数据", {
+    this.paymentModule.logInfo('[WalletPass] 开始从业务数据初始化钱包数据', {
       customer_id: businessData.customer_id,
-      totalAmount: (_c = businessData.amountInfo) == null ? void 0 : _c.totalAmount,
-      subTotal: (_d = businessData.amountInfo) == null ? void 0 : _d.subTotal,
+      totalAmount: businessData.amountInfo?.totalAmount,
+      subTotal: businessData.amountInfo?.subTotal,
       order_wait_pay_amount: businessData.order_wait_pay_amount,
-      products_count: ((_e = businessData.products) == null ? void 0 : _e.length) || 0
+      products_count: businessData.products?.length || 0
     });
     try {
+      // 生成钱包API参数
+      // const walletParams = this.generateWalletParams(businessData);
+
+      // 调用标准的初始化流程
       const result = await this.initializeWalletDataAsync(walletParams);
       const endTime = Date.now();
       const duration = endTime - startTime;
-      this.emitEvent(import_types.WalletPassHooks.OnWalletInitializationCompleted, {
+
+      // 发送初始化完成事件
+      this.emitEvent(_types.WalletPassHooks.OnWalletInitializationCompleted, {
         businessData,
         result,
         startTime,
@@ -479,52 +423,50 @@ var WalletPassPaymentImpl = class {
       });
       this.paymentModule.logInfo(`[WalletPass] 从业务数据初始化钱包数据成功`, {
         duration: `${duration}ms`,
-        walletRecommendList_count: ((_f = result.walletRecommendList) == null ? void 0 : _f.length) || 0,
-        userIdentificationCodes_count: ((_g = result.userIdentificationCodes) == null ? void 0 : _g.length) || 0
+        walletRecommendList_count: result.walletRecommendList?.length || 0,
+        userIdentificationCodes_count: result.userIdentificationCodes?.length || 0
       });
       return result;
     } catch (error) {
       const endTime = Date.now();
       const duration = endTime - startTime;
-      this.emitEvent(import_types.WalletPassHooks.OnWalletInitializationFailed, {
+
+      // 发送初始化失败事件
+      this.emitEvent(_types.WalletPassHooks.OnWalletInitializationFailed, {
         businessData,
-        error,
+        error: error,
         startTime,
         endTime,
         duration
       });
-      this.paymentModule.logError(
-        `[WalletPass] 从业务数据初始化钱包数据失败`,
-        error,
-        {
-          duration: `${duration}ms`,
-          customer_id: businessData.customer_id,
-          totalAmount: (_h = businessData.amountInfo) == null ? void 0 : _h.totalAmount
-        }
-      );
+      this.paymentModule.logError(`[WalletPass] 从业务数据初始化钱包数据失败`, error, {
+        duration: `${duration}ms`,
+        customer_id: businessData.customer_id,
+        totalAmount: businessData.amountInfo?.totalAmount
+      });
       throw error;
     }
   }
+
   /**
    * 获取订单基础详情
    */
   async getOrderBasicDetailAsync(orderId) {
     try {
-      const response = await this.paymentModule.request.get(
-        `/order/order/${orderId}/basic-detail`
-      );
-      return (response == null ? void 0 : response.data) || {};
+      const response = await this.paymentModule.request.get(`/order/order/${orderId}/basic-detail`);
+      return response?.data || {};
     } catch (error) {
       throw error;
     }
   }
+
   /**
    * 初始化钱包数据
    * 先获取推荐列表，再获取用户识别码列表（顺序执行）
    */
   async initializeWalletDataAsync(baseParams) {
-    var _a, _b;
     try {
+      // 格式化用户识别码列表参数
       const identificationParams = {
         ...baseParams,
         available: 2,
@@ -532,11 +474,10 @@ var WalletPassPaymentImpl = class {
         other_exact_codes: [],
         filter_prepare_wallet_pass: 1
       };
-      const [allList, orderBasicDetail] = await Promise.all([
-        this.getUserIdentificationCodeListAsync(identificationParams),
-        baseParams.payment_order_id && typeof baseParams.payment_order_id === "string" && !baseParams.payment_order_id.startsWith("LOCAL_") ? this.getOrderBasicDetailAsync(baseParams.payment_order_id) : Promise.resolve(null)
-      ]);
-      const walletPassEvaluator = (_b = (_a = this.paymentModule.window) == null ? void 0 : _a.getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
+
+      // 并行获取用户识别码列表和订单详情
+      const [allList, orderBasicDetail] = await Promise.all([this.getUserIdentificationCodeListAsync(identificationParams), baseParams.payment_order_id && typeof baseParams.payment_order_id === 'string' && !baseParams.payment_order_id.startsWith('LOCAL_') ? this.getOrderBasicDetailAsync(baseParams.payment_order_id) : Promise.resolve(null)]);
+      const walletPassEvaluator = this.paymentModule.window?.getWalletPassEvaluator?.();
       if (!walletPassEvaluator) {
         return {
           walletRecommendList: [],
@@ -546,44 +487,56 @@ var WalletPassPaymentImpl = class {
           products: []
         };
       }
-      const products = (orderBasicDetail == null ? void 0 : orderBasicDetail.detail) || baseParams.products;
-      const res = walletPassEvaluator == null ? void 0 : walletPassEvaluator.getRecommendedVouchers({
+      const products = orderBasicDetail?.detail || baseParams.products;
+      const res = walletPassEvaluator?.getRecommendedVouchers({
         orderTotalAmount: baseParams.order_wait_pay_amount,
-        products,
+        products: products,
         vouchers: allList
       });
-      const { recommended, transformList, noApplicableVoucher, recommendedAmount } = res;
-      this.walletRecommendList = recommended;
-      this.walletInitData = {
+      const {
+        recommended,
         transformList,
         noApplicableVoucher,
+        recommendedAmount
+      } = res;
+      this.walletRecommendList = recommended;
+
+      // 存储初始化数据到内存中，供 useWalletPass 使用
+      this.walletInitData = {
+        transformList: transformList,
+        noApplicableVoucher: noApplicableVoucher,
         products: products || []
       };
+
+      // // 再获取用户识别码列表
+      // const userIdentificationCodes =
+      //   await this.getUserIdentificationCodeListAsync(identificationParams);
+
       return {
         walletRecommendList: recommended,
         userIdentificationCodes: allList,
-        transformList,
-        noApplicableVoucher,
+        transformList: transformList,
+        noApplicableVoucher: noApplicableVoucher,
         products: products || []
       };
     } catch (error) {
-      this.paymentModule.logError("[WalletPass] 初始化钱包数据失败", error, {
+      this.paymentModule.logError('[WalletPass] 初始化钱包数据失败', error, {
         customer_id: baseParams.customer_id,
         order_expect_amount: baseParams.order_expect_amount
       });
       throw error;
     }
   }
+
   /**
    * 商品或订单金额变化后，使用聚合接口一次重算已选与剩余 WalletPass。
    * Walk-In 不发送 customer_id；会员才携带真实 customer_id。
    */
   async aggregateRecalculateWalletAssetsAsync(businessData, selectedIds) {
-    var _a, _b;
     const walletParams = this.generateWalletParams(businessData);
     const customerId = Number(walletParams.customer_id || 0);
     const requestParams = {
-      ids: selectedIds.map((id) => String(id)),
+      ids: selectedIds.map(id => String(id)),
       exact_codes: this.getSearchedWalletAssetCodes(),
       order_product_amount: walletParams.order_product_amount,
       order_expect_amount: walletParams.order_expect_amount,
@@ -591,59 +544,39 @@ var WalletPassPaymentImpl = class {
       products: walletParams.products,
       available: 2,
       filter_prepare_wallet_pass: 1,
-      sale_channel: walletParams.sale_channel || "pos"
+      sale_channel: walletParams.sale_channel || 'pos'
     };
     if (customerId > 1) {
       requestParams.customer_id = customerId;
     }
-    const response = await this.paymentModule.request.post(
-      "/machinecode/prepare/deduction/aggregate-recalculate",
-      requestParams
-    );
-    const responseData = response == null ? void 0 : response.data;
-    const hasAggregateLists = responseData && (Object.prototype.hasOwnProperty.call(
-      responseData,
-      "recalculate_list"
-    ) || Object.prototype.hasOwnProperty.call(
-      responseData,
-      "customer_wallet_pass_list"
-    ));
+    const response = await this.paymentModule.request.post('/machinecode/prepare/deduction/aggregate-recalculate', requestParams);
+    const responseData = response?.data;
+    const hasAggregateLists = responseData && (Object.prototype.hasOwnProperty.call(responseData, 'recalculate_list') || Object.prototype.hasOwnProperty.call(responseData, 'customer_wallet_pass_list'));
     if (!hasAggregateLists) {
-      throw new Error("WalletPass aggregate response is missing list data");
+      throw new Error('WalletPass aggregate response is missing list data');
     }
-    const recalculateList = Array.isArray(responseData == null ? void 0 : responseData.recalculate_list) ? responseData.recalculate_list : [];
-    const customerWalletPassList = Array.isArray(
-      responseData == null ? void 0 : responseData.customer_wallet_pass_list
-    ) ? responseData.customer_wallet_pass_list : [];
-    const orderedRecalculateList = orderWalletAssetsByIds(
-      recalculateList,
-      selectedIds
-    );
-    const allList = mergeWalletAssets(
-      orderedRecalculateList,
-      customerWalletPassList
-    );
-    const walletPassEvaluator = (_b = (_a = this.paymentModule.window) == null ? void 0 : _a.getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
-    const evaluated = (walletPassEvaluator == null ? void 0 : walletPassEvaluator.getRecommendedVouchers) ? walletPassEvaluator.getRecommendedVouchers({
+    const recalculateList = Array.isArray(responseData?.recalculate_list) ? responseData.recalculate_list : [];
+    const customerWalletPassList = Array.isArray(responseData?.customer_wallet_pass_list) ? responseData.customer_wallet_pass_list : [];
+    const orderedRecalculateList = orderWalletAssetsByIds(recalculateList, selectedIds);
+    const allList = mergeWalletAssets(orderedRecalculateList, customerWalletPassList);
+    const walletPassEvaluator = this.paymentModule.window?.getWalletPassEvaluator?.();
+    const evaluated = walletPassEvaluator?.getRecommendedVouchers ? walletPassEvaluator.getRecommendedVouchers({
       orderTotalAmount: walletParams.order_wait_pay_amount,
       products: walletParams.products,
       vouchers: allList
     }) : {
       recommended: [],
       transformList: allList.filter(isWalletAssetAvailable),
-      noApplicableVoucher: allList.filter(
-        (item) => !isWalletAssetAvailable(item)
-      )
+      noApplicableVoucher: allList.filter(item => !isWalletAssetAvailable(item))
     };
-    const returnedSelectedKeys = new Set(
-      allList.map((item) => getWalletAssetKey(item))
-    );
-    const authoritativeSelectedIds = selectedIds.filter(
-      (id) => returnedSelectedKeys.has(String(id))
-    );
+    // 聚合接口只负责刷新资产数据；选中资格最终由前端 evaluator 重算。
+    // 这里仅移除接口完全未返回的资产，不能把 recalculate_list 当作
+    // 策略选中结果，否则 customer_wallet_pass_list 中的可用券会被误取消。
+    const returnedSelectedKeys = new Set(allList.map(item => getWalletAssetKey(item)));
+    const authoritativeSelectedIds = selectedIds.filter(id => returnedSelectedKeys.has(String(id)));
     this.walletRecommendList = evaluated.recommended || [];
     this.userIdentificationCodes = allList;
-    this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
+    this.emitEvent(_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
       userIdentificationCodes: this.userIdentificationCodes
     });
     this.walletInitData = {
@@ -651,14 +584,11 @@ var WalletPassPaymentImpl = class {
       noApplicableVoucher: evaluated.noApplicableVoucher || [],
       products: walletParams.products || []
     };
-    this.paymentModule.logInfo(
-      "[WalletPass] 聚合重算 WalletPass 完成",
-      {
-        selected_count: recalculateList.length,
-        remaining_count: customerWalletPassList.length,
-        searched_codes_count: requestParams.exact_codes.length
-      }
-    );
+    this.paymentModule.logInfo('[WalletPass] 聚合重算 WalletPass 完成', {
+      selected_count: recalculateList.length,
+      remaining_count: customerWalletPassList.length,
+      searched_codes_count: requestParams.exact_codes.length
+    });
     return {
       walletRecommendList: this.walletRecommendList,
       userIdentificationCodes: this.userIdentificationCodes,
@@ -669,29 +599,27 @@ var WalletPassPaymentImpl = class {
     };
   }
   async getWalletPassRecommendListAsync(params) {
-    var _a;
     try {
-      this.paymentModule.logInfo("[WalletPass] 开始获取钱包推荐列表", {
+      this.paymentModule.logInfo('[WalletPass] 开始获取钱包推荐列表', {
         customer_id: params.customer_id,
         order_expect_amount: params.order_expect_amount,
         sale_channel: params.sale_channel,
-        payment_order_id: (_a = this.walletParams) == null ? void 0 : _a.payment_order_id
+        payment_order_id: this.walletParams?.payment_order_id
       });
-      if (typeof params.payment_order_id === "string" && params.payment_order_id.startsWith("LOCAL_")) {
-        params.payment_order_id = void 0;
+      if (typeof params.payment_order_id === 'string' && params.payment_order_id.startsWith('LOCAL_')) {
+        params.payment_order_id = undefined;
       }
-      const response = await this.paymentModule.request.post(
-        "/machinecode/prepare/deduction/recommend",
-        params
-        // 将 params 作为请求体数据
+      const response = await this.paymentModule.request.post('/machinecode/prepare/deduction/recommend', params // 将 params 作为请求体数据
       );
-      this.walletRecommendList = (response == null ? void 0 : response.data) || [];
-      this.emitEvent(import_types.WalletPassHooks.OnWalletRecommendListUpdated, {
+      this.walletRecommendList = response?.data || [];
+
+      // 发送钱包推荐列表更新事件（使用专用的WalletPassHooks）
+      this.emitEvent(_types.WalletPassHooks.OnWalletRecommendListUpdated, {
         walletRecommendList: this.walletRecommendList
       });
-      this.paymentModule.logInfo("[WalletPass] 钱包推荐列表已更新", {
+      this.paymentModule.logInfo('[WalletPass] 钱包推荐列表已更新', {
         count: this.walletRecommendList.length,
-        items: this.walletRecommendList.map((item) => ({
+        items: this.walletRecommendList.map(item => ({
           voucher_id: item.voucher_id,
           name: item.name,
           amount: item.amount,
@@ -700,62 +628,61 @@ var WalletPassPaymentImpl = class {
       });
       return this.walletRecommendList;
     } catch (error) {
-      this.paymentModule.logError("[WalletPass] 获取钱包推荐列表失败", error, {
+      this.paymentModule.logError('[WalletPass] 获取钱包推荐列表失败', error, {
         customer_id: params.customer_id,
         order_expect_amount: params.order_expect_amount,
         sale_channel: params.sale_channel
       });
+      // throw error;
       return [];
     }
   }
   formatWalletPassList2PreparePayments(list) {
-    return (0, import_utils.formatWalletPassList2PreparePayments)(list);
+    return (0, _utils.formatWalletPassList2PreparePayments)(list);
   }
   async getUserIdentificationCodeListAsync(params) {
-    var _a, _b, _c;
     try {
       const newParams = {
         ...this.walletParams,
         ...params
       };
-      if (!((_a = newParams.products) == null ? void 0 : _a.length)) {
-        this.paymentModule.logInfo("[WalletPass] 商品列表为空，跳过获取用户识别码列表");
+      if (!newParams.products?.length) {
+        this.paymentModule.logInfo('[WalletPass] 商品列表为空，跳过获取用户识别码列表');
         return [];
       }
       const platform = this.paymentModule.getPlatform();
-      if (platform === "pc" || platform === "h5") {
+      if (platform === 'pc' || platform === 'h5') {
         this.userIdentificationCodes = [];
-        this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
+        this.emitEvent(_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
           userIdentificationCodes: []
         });
-        this.paymentModule.logInfo(
-          "[WalletPass] 用户端平台跳过获取用户识别码列表",
-          { platform }
-        );
+        this.paymentModule.logInfo('[WalletPass] 用户端平台跳过获取用户识别码列表', {
+          platform
+        });
         return [];
       }
-      if (typeof newParams.payment_order_id === "string" && newParams.payment_order_id.startsWith("LOCAL_")) {
-        newParams.payment_order_id = void 0;
+      if (typeof newParams.payment_order_id === 'string' && newParams.payment_order_id.startsWith('LOCAL_')) {
+        newParams.payment_order_id = undefined;
       }
-      this.paymentModule.logInfo("[WalletPass] 开始获取用户识别码列表", {
+      this.paymentModule.logInfo('[WalletPass] 开始获取用户识别码列表', {
         customer_id: newParams.customer_id,
         available: newParams.available,
-        prepare_payments_count: ((_b = newParams.prepare_payments) == null ? void 0 : _b.length) || 0,
+        prepare_payments_count: newParams.prepare_payments?.length || 0,
         filter_prepare_wallet_pass: newParams.filter_prepare_wallet_pass,
-        payment_order_id: (_c = this.walletParams) == null ? void 0 : _c.payment_order_id
+        payment_order_id: this.walletParams?.payment_order_id
       });
-      const response = await this.paymentModule.request.post(
-        "/machinecode/prepare/deduction",
-        newParams
-      );
-      const sortedData = (0, import_utils.sortUserIdentificationCodeList)((response == null ? void 0 : response.data) || []);
+      const response = await this.paymentModule.request.post('/machinecode/prepare/deduction', newParams);
+      // 对获取到的数据进行排序，将错误码为 500100、500200、500300 的项目排到最后
+      const sortedData = (0, _utils.sortUserIdentificationCodeList)(response?.data || []);
       this.userIdentificationCodes = sortedData;
-      this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
+
+      // 发送用户识别码列表更新事件（使用专用的WalletPassHooks）
+      this.emitEvent(_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
         userIdentificationCodes: this.userIdentificationCodes
       });
-      this.paymentModule.logInfo("[WalletPass] 用户识别码列表已更新", {
+      this.paymentModule.logInfo('[WalletPass] 用户识别码列表已更新', {
         count: this.userIdentificationCodes.length,
-        sorted_items: this.userIdentificationCodes.slice(0, 5).map((item) => ({
+        sorted_items: this.userIdentificationCodes.slice(0, 5).map(item => ({
           code: item.code,
           error_code: item.error_code,
           error_msg: item.error_msg
@@ -763,17 +690,14 @@ var WalletPassPaymentImpl = class {
       });
       return this.userIdentificationCodes;
     } catch (error) {
-      this.paymentModule.logError(
-        "[WalletPass] 获取用户识别码列表失败",
-        error,
-        {
-          customer_id: params.customer_id,
-          available: params.available
-        }
-      );
+      this.paymentModule.logError('[WalletPass] 获取用户识别码列表失败', error, {
+        customer_id: params.customer_id,
+        available: params.available
+      });
       return [];
     }
   }
+
   /**
    * 搜索识别码信息
    * 通过识别码搜索相关的钱包通行证信息
@@ -782,103 +706,107 @@ var WalletPassPaymentImpl = class {
    */
   async searchIdentificationCodeAsync(params, config = {}) {
     try {
-      const { code } = params;
-      this.paymentModule.logInfo("[WalletPass] 开始搜索识别码", {
-        code,
+      const {
+        code
+      } = params;
+      this.paymentModule.logInfo('[WalletPass] 开始搜索识别码', {
+        code: code,
         code_length: code.length,
         noCache: config.noCache || false
       });
-      const isWalletCode = code.startsWith("WL") || code.startsWith("200") && code.length === 10;
+
+      // 新钱包规则
+      const isWalletCode = code.startsWith('WL') || code.startsWith('200') && code.length === 10;
       if (isWalletCode) {
+        // 钱包识别码直接调用专门接口，不缓存，直接返回
         const walletDetailParams = {
-          code,
+          code: code,
           with_customer: 1,
-          with: ["wallet"]
+          with: ['wallet']
         };
-        this.paymentModule.logInfo("[WalletPass] 搜索钱包识别码", {
-          code,
+        this.paymentModule.logInfo('[WalletPass] 搜索钱包识别码', {
+          code: code,
           with_customer: walletDetailParams.with_customer,
           with: walletDetailParams.with
         });
-        const response2 = await this.paymentModule.request.post(
-          "/wallet/detail/search",
-          walletDetailParams
-        );
-        const searchResults2 = (response2 == null ? void 0 : response2.data) || [];
-        this.paymentModule.logInfo("[WalletPass] 钱包识别码搜索完成", {
-          code,
-          results_count: searchResults2.length,
-          type: "walletCode"
+        const response = await this.paymentModule.request.post('/wallet/detail/search', walletDetailParams);
+        const searchResults = response?.data || [];
+        this.paymentModule.logInfo('[WalletPass] 钱包识别码搜索完成', {
+          code: code,
+          results_count: searchResults.length,
+          type: 'walletCode'
         });
         return {
-          type: "walletCode",
-          data: searchResults2
+          type: 'walletCode',
+          data: searchResults
         };
       }
+
+      // 合并钱包参数和搜索参数
       const baseWalletParams = this.walletParams;
+
+      // 构建完整的搜索参数，包含钱包扣款推荐的所有参数
       const searchParams = {
         // 基础钱包参数
-        sale_channel: params.sale_channel ?? (baseWalletParams == null ? void 0 : baseWalletParams.sale_channel) ?? "pos",
-        customer_id: params.customer_id ?? (baseWalletParams == null ? void 0 : baseWalletParams.customer_id),
-        order_expect_amount: params.order_expect_amount ?? (baseWalletParams == null ? void 0 : baseWalletParams.order_expect_amount),
-        order_product_amount: params.order_product_amount ?? (baseWalletParams == null ? void 0 : baseWalletParams.order_product_amount),
-        order_wait_pay_amount: params.order_wait_pay_amount ?? (baseWalletParams == null ? void 0 : baseWalletParams.order_wait_pay_amount),
-        order_behavior_count_customer_id: params.order_behavior_count_customer_id ?? (baseWalletParams == null ? void 0 : baseWalletParams.order_behavior_count_customer_id) ?? params.customer_id ?? (baseWalletParams == null ? void 0 : baseWalletParams.customer_id),
-        products: params.products ?? (baseWalletParams == null ? void 0 : baseWalletParams.products) ?? [],
-        prepare_payments: params.prepare_payments ?? (baseWalletParams == null ? void 0 : baseWalletParams.prepare_payments) ?? [],
+        sale_channel: params.sale_channel ?? baseWalletParams?.sale_channel ?? 'pos',
+        customer_id: params.customer_id ?? baseWalletParams?.customer_id,
+        order_expect_amount: params.order_expect_amount ?? baseWalletParams?.order_expect_amount,
+        order_product_amount: params.order_product_amount ?? baseWalletParams?.order_product_amount,
+        order_wait_pay_amount: params.order_wait_pay_amount ?? baseWalletParams?.order_wait_pay_amount,
+        order_behavior_count_customer_id: params.order_behavior_count_customer_id ?? baseWalletParams?.order_behavior_count_customer_id ?? params.customer_id ?? baseWalletParams?.customer_id,
+        products: params.products ?? baseWalletParams?.products ?? [],
+        prepare_payments: params.prepare_payments ?? baseWalletParams?.prepare_payments ?? [],
         multiple: 1,
         // 搜索特有参数
         code: params.code,
-        payment_order_id: baseWalletParams == null ? void 0 : baseWalletParams.payment_order_id
+        payment_order_id: baseWalletParams?.payment_order_id
       };
-      this.paymentModule.logInfo("[WalletPass] 搜索普通识别码", {
+      this.paymentModule.logInfo('[WalletPass] 搜索普通识别码', {
         code: searchParams.code,
         customer_id: searchParams.customer_id,
         order_expect_amount: searchParams.order_expect_amount,
         multiple: searchParams.multiple,
-        payment_order_id: baseWalletParams == null ? void 0 : baseWalletParams.payment_order_id
+        payment_order_id: baseWalletParams?.payment_order_id
       });
-      if (typeof searchParams.payment_order_id === "string" && searchParams.payment_order_id.startsWith("LOCAL_")) {
-        searchParams.payment_order_id = void 0;
+      if (typeof searchParams.payment_order_id === 'string' && searchParams.payment_order_id.startsWith('LOCAL_')) {
+        searchParams.payment_order_id = undefined;
       }
-      const response = await this.paymentModule.request.post(
-        "/machinecode/prepare/deduction/search",
-        searchParams
-      );
-      const searchResults = (response == null ? void 0 : response.data) || [];
+      const response = await this.paymentModule.request.post('/machinecode/prepare/deduction/search', searchParams);
+      const searchResults = response?.data || [];
       if (config.noCache) {
         return {
-          type: "normalCode",
+          type: 'normalCode',
           data: searchResults
         };
       }
+
+      // 将搜索结果存储到缓存数组中
       if (searchResults.length > 0) {
-        const existingCodes = new Set(
-          this.searchResults.map((item) => item.code)
-        );
-        const newResults = searchResults.filter(
-          (item) => !existingCodes.has(item.code)
-        );
+        // 避免重复存储相同的识别码
+        const existingCodes = new Set(this.searchResults.map(item => item.code));
+        const newResults = searchResults.filter(item => !existingCodes.has(item.code));
         this.searchResults.push(...newResults);
       }
-      this.emitEvent(import_types.WalletPassHooks.OnSearchIdentificationCodeCompleted, {
+
+      // 通过事件暴露当前搜索结果和缓存结果
+      this.emitEvent(_types.WalletPassHooks.OnSearchIdentificationCodeCompleted, {
         searchCode: params.code,
         currentSearchResults: searchResults,
         cachedSearchResults: [...this.searchResults],
         searchParams: params
       });
-      this.paymentModule.logInfo("[WalletPass] 普通识别码搜索完成", {
+      this.paymentModule.logInfo('[WalletPass] 普通识别码搜索完成', {
         code: params.code,
         results_count: searchResults.length,
         cached_results_count: this.searchResults.length,
-        type: "normalCode"
+        type: 'normalCode'
       });
       return {
-        type: "normalCode",
+        type: 'normalCode',
         data: searchResults
       };
     } catch (error) {
-      this.paymentModule.logError("[WalletPass] 搜索识别码信息失败", error, {
+      this.paymentModule.logError('[WalletPass] 搜索识别码信息失败', error, {
         code: params.code,
         customer_id: params.customer_id,
         order_expect_amount: params.order_expect_amount
@@ -886,6 +814,7 @@ var WalletPassPaymentImpl = class {
       throw error;
     }
   }
+
   /**
    * 刷新购物车与结账共享的钱包资产。
    *
@@ -893,42 +822,39 @@ var WalletPassPaymentImpl = class {
    * 推荐结果只作为可用性/金额计算输入，不会自动成为 selectedIds。
    */
   async refreshWalletAssetsFromBusinessAsync(businessData, options = {}) {
-    var _a;
     const requestSequence = ++this.walletAssetsRequestSequence;
     const nextCustomerId = businessData.customer_id;
     const previousCustomerId = this.walletAssetsState.customerId;
-    const customerChanged = String(previousCustomerId ?? "") !== String(nextCustomerId ?? "");
+    const customerChanged = String(previousCustomerId ?? '') !== String(nextCustomerId ?? '');
     const preserveSelection = options.preserveSelection !== false && !customerChanged;
     if (customerChanged) {
       this.clearSearchResults();
     }
-    const committedKeys = new Set(
-      this.walletAssetsState.committedIds.map((id) => String(id))
-    );
-    const committedItems = this.walletAssetsState.items.filter(
-      (item) => committedKeys.has(getWalletAssetKey(item))
-    );
+    const committedKeys = new Set(this.walletAssetsState.committedIds.map(id => String(id)));
+    const committedItems = this.walletAssetsState.items.filter(item => committedKeys.has(getWalletAssetKey(item)));
     const selectedIds = preserveSelection ? [...this.walletAssetsState.selectedIds] : [];
-    const selectionSources = preserveSelection ? { ...this.walletAssetsState.selectionSources } : {};
-    const scanSelectedAssets = preserveSelection ? this.walletAssetsState.selectedItems.filter((asset) => {
+    const selectionSources = preserveSelection ? {
+      ...this.walletAssetsState.selectionSources
+    } : {};
+    const scanSelectedAssets = preserveSelection ? this.walletAssetsState.selectedItems.filter(asset => {
       const assetId = getWalletAssetId(asset);
-      return assetId !== void 0 && assetId !== null && selectionSources[String(assetId)] === "scan";
+      return assetId !== undefined && assetId !== null && selectionSources[String(assetId)] === 'scan';
     }) : [];
-    const manualEditAmountByKey = /* @__PURE__ */ new Map();
+    const manualEditAmountByKey = new Map();
     if (preserveSelection) {
-      this.walletAssetsState.selectedItems.forEach((asset) => {
-        if (typeof (asset == null ? void 0 : asset.edit_current_amount) !== "number")
-          return;
-        manualEditAmountByKey.set(
-          getWalletAssetKey(asset),
-          asset.edit_current_amount
-        );
+      this.walletAssetsState.selectedItems.forEach(asset => {
+        if (typeof asset?.edit_current_amount !== 'number') return;
+        manualEditAmountByKey.set(getWalletAssetKey(asset), asset.edit_current_amount);
       });
     }
-    if (!((_a = businessData.products) == null ? void 0 : _a.length)) {
+
+    // aggregate-recalculate 不接受空商品列表。
+    // 清空购物车时保留扫码资产供后续加购恢复；只有手动 Remove/Clear
+    // 会取消自动应用资格，商品变化导致的自动失效需要重新进入待选队列。
+    if (!businessData.products?.length) {
       this.queuePendingAutoSelectForAssets(scanSelectedAssets);
       this.generateWalletParams(businessData);
-      const restoredSearchedAssets = this.searchResults.filter(isWalletPaymentAsset).map((item) => ({
+      const restoredSearchedAssets = this.searchResults.filter(isWalletPaymentAsset).map(item => ({
         ...item,
         actualDeduction: 0,
         deductionDetails: [],
@@ -947,16 +873,13 @@ var WalletPassPaymentImpl = class {
         orderTotalAmount: 0,
         products: []
       };
-      this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
+      this.emitEvent(_types.WalletPassHooks.OnUserIdentificationCodesUpdated, {
         userIdentificationCodes: []
       });
       return this.publishWalletAssetsState({
-        status: "ready",
+        status: 'ready',
         customerId: nextCustomerId,
-        items: mergeWalletAssets(
-          restoredSearchedAssets,
-          committedItems
-        ),
+        items: mergeWalletAssets(restoredSearchedAssets, committedItems),
         selectedIds: [],
         selectedItems: [],
         selectionSources: {},
@@ -965,7 +888,7 @@ var WalletPassPaymentImpl = class {
       });
     }
     this.publishWalletAssetsState({
-      status: "loading",
+      status: 'loading',
       customerId: nextCustomerId,
       items: preserveSelection ? this.walletAssetsState.items : committedItems,
       selectedIds,
@@ -977,11 +900,8 @@ var WalletPassPaymentImpl = class {
     try {
       const searchedWalletAssetCodes = preserveSelection ? this.getSearchedWalletAssetCodes() : [];
       const useAggregateRecalculate = preserveSelection && (selectedIds.length > 0 || searchedWalletAssetCodes.length > 0);
-      const aggregateResult = useAggregateRecalculate ? await this.aggregateRecalculateWalletAssetsAsync(
-        businessData,
-        selectedIds
-      ) : null;
-      const result = aggregateResult || await this.initializeWalletDataFromBusinessAsync(businessData);
+      const aggregateResult = useAggregateRecalculate ? await this.aggregateRecalculateWalletAssetsAsync(businessData, selectedIds) : null;
+      const result = aggregateResult || (await this.initializeWalletDataFromBusinessAsync(businessData));
       if (requestSequence !== this.walletAssetsRequestSequence) {
         return this.getWalletAssetsState();
       }
@@ -989,86 +909,56 @@ var WalletPassPaymentImpl = class {
         orderTotalAmount: Number(businessData.order_wait_pay_amount || 0),
         products: result.products || businessData.products || []
       };
-      const authoritativeSelectedIds = (aggregateResult == null ? void 0 : aggregateResult.authoritativeSelectedIds) || selectedIds;
+      const authoritativeSelectedIds = aggregateResult?.authoritativeSelectedIds || selectedIds;
       if (aggregateResult) {
-        const returnedAggregateKeys = new Set(
-          [
-            ...result.transformList || [],
-            ...result.noApplicableVoucher || []
-          ].map((item) => getWalletAssetKey(item))
-        );
-        const missingSelectedKeys = new Set(
-          selectedIds.map((id) => String(id)).filter((id) => !returnedAggregateKeys.has(id))
-        );
+        const returnedAggregateKeys = new Set([...(result.transformList || []), ...(result.noApplicableVoucher || [])].map(item => getWalletAssetKey(item)));
+        const missingSelectedKeys = new Set(selectedIds.map(id => String(id)).filter(id => !returnedAggregateKeys.has(id)));
         if (missingSelectedKeys.size > 0) {
-          this.searchResults = this.searchResults.filter(
-            (item) => !missingSelectedKeys.has(getWalletAssetKey(item))
-          );
+          this.searchResults = this.searchResults.filter(item => !missingSelectedKeys.has(getWalletAssetKey(item)));
         }
       }
-      const searchedWalletAssets = preserveSelection ? this.syncSearchedWalletAssets([
-        ...result.transformList || [],
-        ...result.noApplicableVoucher || []
-      ]) : [];
+      const searchedWalletAssets = preserveSelection ? this.syncSearchedWalletAssets([...(result.transformList || []), ...(result.noApplicableVoucher || [])]) : [];
       if (requestSequence !== this.walletAssetsRequestSequence) {
         return this.getWalletAssetsState();
       }
-      const recommendedKeys = new Set(
-        (result.walletRecommendList || []).map(
-          (asset) => getWalletAssetKey(asset)
-        )
-      );
-      const items = mergeWalletAssets(
-        preserveSelection && !aggregateResult ? this.walletAssetsState.selectedItems : [],
-        searchedWalletAssets,
-        result.transformList || [],
-        result.noApplicableVoucher || []
-      ).map((asset) => {
+      const recommendedKeys = new Set((result.walletRecommendList || []).map(asset => getWalletAssetKey(asset)));
+      const items = mergeWalletAssets(preserveSelection && !aggregateResult ? this.walletAssetsState.selectedItems : [], searchedWalletAssets, result.transformList || [], result.noApplicableVoucher || []).map(asset => {
         const assetKey = getWalletAssetKey(asset);
         return {
           ...asset,
-          ...manualEditAmountByKey.has(assetKey) ? {
+          ...(manualEditAmountByKey.has(assetKey) ? {
             edit_current_amount: manualEditAmountByKey.get(assetKey)
-          } : {},
+          } : {}),
           _wallet_asset_recommended: recommendedKeys.has(assetKey)
         };
       });
       const latestSelectedIds = preserveSelection ? authoritativeSelectedIds : [];
-      const latestSelectionSources = preserveSelection ? { ...this.walletAssetsState.selectionSources } : {};
-      const pendingAutoSelectAssets = this.walletAssetsBehavior.autoSelectAfterSearch ? items.filter(
-        (asset) => this.isPendingAutoSelectAsset(asset) && isWalletAssetAvailable(asset)
-      ) : [];
-      const requestedKeySet = new Set(
-        latestSelectedIds.map((id) => String(id))
-      );
-      pendingAutoSelectAssets.forEach((asset) => {
+      const latestSelectionSources = preserveSelection ? {
+        ...this.walletAssetsState.selectionSources
+      } : {};
+      const pendingAutoSelectAssets = this.walletAssetsBehavior.autoSelectAfterSearch ? items.filter(asset => this.isPendingAutoSelectAsset(asset) && isWalletAssetAvailable(asset)) : [];
+      const requestedKeySet = new Set(latestSelectedIds.map(id => String(id)));
+      pendingAutoSelectAssets.forEach(asset => {
         const assetId = getWalletAssetId(asset);
-        if (assetId === void 0 || assetId === null)
-          return;
+        if (assetId === undefined || assetId === null) return;
         const assetKey = String(assetId);
         if (!requestedKeySet.has(assetKey)) {
           requestedKeySet.add(assetKey);
           latestSelectedIds.push(assetId);
         }
-        latestSelectionSources[assetKey] = "scan";
+        latestSelectionSources[assetKey] = 'scan';
       });
-      const nextState = this.recalculateWalletAssets(
-        items,
-        latestSelectedIds,
-        latestSelectionSources
-      );
-      const selectedKeySet = new Set(
-        nextState.selectedIds.map((id) => String(id))
-      );
-      pendingAutoSelectAssets.forEach((asset) => {
+      const nextState = this.recalculateWalletAssets(items, latestSelectedIds, latestSelectionSources);
+      const selectedKeySet = new Set(nextState.selectedIds.map(id => String(id)));
+      pendingAutoSelectAssets.forEach(asset => {
         const assetId = getWalletAssetId(asset);
-        if (assetId !== void 0 && assetId !== null && selectedKeySet.has(String(assetId))) {
+        if (assetId !== undefined && assetId !== null && selectedKeySet.has(String(assetId))) {
           this.clearPendingAutoSelectForAsset(asset);
         }
       });
-      const droppedScanSelectedAssets = scanSelectedAssets.filter((asset) => {
+      const droppedScanSelectedAssets = scanSelectedAssets.filter(asset => {
         const assetId = getWalletAssetId(asset);
-        return assetId !== void 0 && assetId !== null && !selectedKeySet.has(String(assetId));
+        return assetId !== undefined && assetId !== null && !selectedKeySet.has(String(assetId));
       });
       this.queuePendingAutoSelectForAssets(droppedScanSelectedAssets);
       return nextState;
@@ -1076,17 +966,13 @@ var WalletPassPaymentImpl = class {
       if (requestSequence !== this.walletAssetsRequestSequence) {
         return this.getWalletAssetsState();
       }
-      this.paymentModule.logError(
-        "[WalletPass] 刷新共享钱包资产失败，保留刷新前状态",
-        error,
-        {
-          customer_id: businessData.customer_id,
-          selected_ids: selectedIds,
-          searched_codes: this.getSearchedWalletAssetCodes()
-        }
-      );
+      this.paymentModule.logError('[WalletPass] 刷新共享钱包资产失败，保留刷新前状态', error, {
+        customer_id: businessData.customer_id,
+        selected_ids: selectedIds,
+        searched_codes: this.getSearchedWalletAssetCodes()
+      });
       return this.publishWalletAssetsState({
-        status: "error",
+        status: 'error',
         items: preserveSelection ? this.walletAssetsState.items : committedItems,
         selectedIds: preserveSelection ? this.walletAssetsState.selectedIds : [],
         selectedItems: preserveSelection ? this.walletAssetsState.selectedItems : [],
@@ -1104,17 +990,19 @@ var WalletPassPaymentImpl = class {
       selectedIds: [...this.walletAssetsState.selectedIds],
       selectedItems: [...this.walletAssetsState.selectedItems],
       committedIds: [...this.walletAssetsState.committedIds],
-      selectionSources: { ...this.walletAssetsState.selectionSources }
+      selectionSources: {
+        ...this.walletAssetsState.selectionSources
+      }
     };
   }
   exportWalletAssetsSnapshot() {
     return {
       state: this.getWalletAssetsState(),
       searchResults: [...this.searchResults],
-      pendingAutoSelectSearchCodes: [
-        ...this.pendingAutoSelectSearchCodes
-      ],
-      walletParams: this.walletParams ? { ...this.walletParams } : null,
+      pendingAutoSelectSearchCodes: [...this.pendingAutoSelectSearchCodes],
+      walletParams: this.walletParams ? {
+        ...this.walletParams
+      } : null,
       calculationContext: {
         orderTotalAmount: this.walletAssetsCalculationContext.orderTotalAmount,
         products: [...this.walletAssetsCalculationContext.products]
@@ -1122,20 +1010,16 @@ var WalletPassPaymentImpl = class {
     };
   }
   importWalletAssetsSnapshot(snapshot) {
-    var _a, _b;
-    if (!(snapshot == null ? void 0 : snapshot.state))
-      return this.getWalletAssetsState();
+    if (!snapshot?.state) return this.getWalletAssetsState();
     this.walletAssetsRequestSequence += 1;
     this.searchResults = Array.isArray(snapshot.searchResults) ? [...snapshot.searchResults] : [];
-    this.pendingAutoSelectSearchCodes = this.walletAssetsBehavior.autoSelectAfterSearch && Array.isArray(snapshot.pendingAutoSelectSearchCodes) ? new Set(
-      snapshot.pendingAutoSelectSearchCodes.map(normalizeWalletAssetCode).filter(Boolean)
-    ) : /* @__PURE__ */ new Set();
-    this.walletParams = snapshot.walletParams ? { ...snapshot.walletParams } : null;
+    this.pendingAutoSelectSearchCodes = this.walletAssetsBehavior.autoSelectAfterSearch && Array.isArray(snapshot.pendingAutoSelectSearchCodes) ? new Set(snapshot.pendingAutoSelectSearchCodes.map(normalizeWalletAssetCode).filter(Boolean)) : new Set();
+    this.walletParams = snapshot.walletParams ? {
+      ...snapshot.walletParams
+    } : null;
     this.walletAssetsCalculationContext = {
-      orderTotalAmount: Number(
-        ((_a = snapshot.calculationContext) == null ? void 0 : _a.orderTotalAmount) || 0
-      ),
-      products: Array.isArray((_b = snapshot.calculationContext) == null ? void 0 : _b.products) ? [...snapshot.calculationContext.products] : []
+      orderTotalAmount: Number(snapshot.calculationContext?.orderTotalAmount || 0),
+      products: Array.isArray(snapshot.calculationContext?.products) ? [...snapshot.calculationContext.products] : []
     };
     return this.publishWalletAssetsState({
       ...snapshot.state,
@@ -1147,26 +1031,22 @@ var WalletPassPaymentImpl = class {
     });
   }
   updateWalletAssetEditAmountInCaches(assetKey, amount) {
-    const updateAsset = (asset) => getWalletAssetKey(asset) === assetKey ? { ...asset, edit_current_amount: amount } : asset;
-    this.searchResults = this.searchResults.map(
-      updateAsset
-    );
+    const updateAsset = asset => getWalletAssetKey(asset) === assetKey ? {
+      ...asset,
+      edit_current_amount: amount
+    } : asset;
+    this.searchResults = this.searchResults.map(updateAsset);
     return this.walletAssetsState.items.map(updateAsset);
   }
   selectWalletAsset(assetId, options) {
     const assetKey = String(assetId);
-    const asset = this.walletAssetsState.items.find(
-      (item) => getWalletAssetKey(item) === assetKey
-    );
-    const committedKeys = new Set(
-      this.walletAssetsState.committedIds.map((id) => String(id))
-    );
-    if (committedKeys.has(assetKey))
-      return this.getWalletAssetsState();
-    const selectedIds = this.walletAssetsState.selectedIds.filter(
-      (id) => String(id) !== assetKey
-    );
-    const selectionSources = { ...this.walletAssetsState.selectionSources };
+    const asset = this.walletAssetsState.items.find(item => getWalletAssetKey(item) === assetKey);
+    const committedKeys = new Set(this.walletAssetsState.committedIds.map(id => String(id)));
+    if (committedKeys.has(assetKey)) return this.getWalletAssetsState();
+    const selectedIds = this.walletAssetsState.selectedIds.filter(id => String(id) !== assetKey);
+    const selectionSources = {
+      ...this.walletAssetsState.selectionSources
+    };
     delete selectionSources[assetKey];
     let nextItems = this.walletAssetsState.items;
     if (options.selected) {
@@ -1174,87 +1054,60 @@ var WalletPassPaymentImpl = class {
         return this.getWalletAssetsState();
       }
       selectedIds.push(assetId);
-      selectionSources[assetKey] = options.source || "manual";
+      selectionSources[assetKey] = options.source || 'manual';
     } else if (asset) {
       this.clearPendingAutoSelectForAsset(asset);
-      nextItems = this.updateWalletAssetEditAmountInCaches(
-        assetKey,
-        void 0
-      );
+      nextItems = this.updateWalletAssetEditAmountInCaches(assetKey, undefined);
     }
-    const nextState = this.recalculateWalletAssets(
-      nextItems,
-      selectedIds,
-      selectionSources
-    );
-    if (options.selected && asset && nextState.selectedIds.some((id) => String(id) === assetKey)) {
+    const nextState = this.recalculateWalletAssets(nextItems, selectedIds, selectionSources);
+    if (options.selected && asset && nextState.selectedIds.some(id => String(id) === assetKey)) {
       this.clearPendingAutoSelectForAsset(asset);
     }
     return nextState;
   }
+
   /**
    * 更新已选资产的手动金额。只允许在当前实际抵扣额内向下调整，
    * 金额为 0 时沿用 legacy 行为取消选择。
    */
   updateWalletAssetAmount(assetId, amount) {
     const assetKey = String(assetId);
-    const committedKeys = new Set(
-      this.walletAssetsState.committedIds.map((id) => String(id))
-    );
-    const selectedKeys = new Set(
-      this.walletAssetsState.selectedIds.map((id) => String(id))
-    );
-    const asset = this.walletAssetsState.items.find(
-      (item) => getWalletAssetKey(item) === assetKey
-    );
+    const committedKeys = new Set(this.walletAssetsState.committedIds.map(id => String(id)));
+    const selectedKeys = new Set(this.walletAssetsState.selectedIds.map(id => String(id)));
+    const asset = this.walletAssetsState.items.find(item => getWalletAssetKey(item) === assetKey);
     const requestedAmount = Number(amount);
     if (!asset || committedKeys.has(assetKey) || !selectedKeys.has(assetKey) || !Number.isFinite(requestedAmount) || requestedAmount < 0) {
       return this.getWalletAssetsState();
     }
     const selectedIds = [...this.walletAssetsState.selectedIds];
-    const selectionSources = { ...this.walletAssetsState.selectionSources };
+    const selectionSources = {
+      ...this.walletAssetsState.selectionSources
+    };
     if (requestedAmount === 0) {
-      const nextItems2 = this.updateWalletAssetEditAmountInCaches(
-        assetKey,
-        void 0
-      );
+      const nextItems = this.updateWalletAssetEditAmountInCaches(assetKey, undefined);
       delete selectionSources[assetKey];
       this.clearPendingAutoSelectForAsset(asset);
-      return this.recalculateWalletAssets(
-        nextItems2,
-        selectedIds.filter((id) => String(id) !== assetKey),
-        selectionSources
-      );
+      return this.recalculateWalletAssets(nextItems, selectedIds.filter(id => String(id) !== assetKey), selectionSources);
     }
     const currentDeductionAmount = getWalletAssetDeductionAmount(asset);
     const editAmount = Math.min(requestedAmount, currentDeductionAmount);
-    if (editAmount <= 0)
-      return this.getWalletAssetsState();
-    const nextItems = this.updateWalletAssetEditAmountInCaches(
-      assetKey,
-      editAmount
-    );
-    return this.recalculateWalletAssets(
-      nextItems,
-      selectedIds,
-      selectionSources
-    );
+    if (editAmount <= 0) return this.getWalletAssetsState();
+    const nextItems = this.updateWalletAssetEditAmountInCaches(assetKey, editAmount);
+    return this.recalculateWalletAssets(nextItems, selectedIds, selectionSources);
   }
   async scanWalletAssetAsync(code) {
-    const normalizedCode = String(code || "").trim();
+    const normalizedCode = String(code || '').trim();
     if (!normalizedCode) {
       return {
-        type: "normalCode",
+        type: 'normalCode',
         selected: false,
         state: this.getWalletAssetsState()
       };
     }
-    const selectedAsset = this.walletAssetsState.selectedItems.find(
-      (asset2) => matchesWalletAssetCode(asset2, normalizedCode)
-    );
+    const selectedAsset = this.walletAssetsState.selectedItems.find(asset => matchesWalletAssetCode(asset, normalizedCode));
     if (selectedAsset) {
       return {
-        type: "normalCode",
+        type: 'normalCode',
         asset: selectedAsset,
         selected: true,
         state: this.getWalletAssetsState()
@@ -1262,25 +1115,16 @@ var WalletPassPaymentImpl = class {
     }
     this.walletAssetsRequestSequence += 1;
     const result = await this.searchIdentificationCodeAsync({
-      ...this.walletParams || {},
+      ...(this.walletParams || {}),
       code: normalizedCode,
-      prepare_payments: this.formatWalletPassList2PreparePayments(
-        this.walletAssetsState.selectedItems
-      )
+      prepare_payments: this.formatWalletPassList2PreparePayments(this.walletAssetsState.selectedItems)
     });
-    const paymentAssets = this.formatSearchedWalletPaymentAssets(
-      result.data.filter(isWalletPaymentAsset)
-    );
+    const paymentAssets = this.formatSearchedWalletPaymentAssets(result.data.filter(isWalletPaymentAsset));
     if (paymentAssets.length > 0) {
-      this.searchResults = mergeWalletAssets(
-        this.searchResults,
-        paymentAssets
-      );
+      this.searchResults = mergeWalletAssets(this.searchResults, paymentAssets);
     }
-    const asset = paymentAssets.find(
-      (item) => String((item == null ? void 0 : item.code) || "") === normalizedCode
-    ) || paymentAssets[0];
-    if (!asset || result.type === "walletCode") {
+    const asset = paymentAssets.find(item => String(item?.code || '') === normalizedCode) || paymentAssets[0];
+    if (!asset || result.type === 'walletCode') {
       return {
         type: result.type,
         asset,
@@ -1289,30 +1133,20 @@ var WalletPassPaymentImpl = class {
       };
     }
     const items = mergeWalletAssets(this.walletAssetsState.items, [asset]);
-    const recalculatedState = this.recalculateWalletAssets(
-      items,
-      this.walletAssetsState.selectedIds,
-      this.walletAssetsState.selectionSources
-    );
+    const recalculatedState = this.recalculateWalletAssets(items, this.walletAssetsState.selectedIds, this.walletAssetsState.selectionSources);
     const assetId = getWalletAssetId(asset);
-    const recalculatedAsset = assetId === void 0 ? void 0 : recalculatedState.items.find(
-      (item) => getWalletAssetKey(item) === String(assetId)
-    );
-    const selected = this.walletAssetsBehavior.autoSelectAfterSearch && assetId !== void 0 && isWalletAssetAvailable(recalculatedAsset) ? this.selectWalletAsset(assetId, {
+    const recalculatedAsset = assetId === undefined ? undefined : recalculatedState.items.find(item => getWalletAssetKey(item) === String(assetId));
+    const selected = this.walletAssetsBehavior.autoSelectAfterSearch && assetId !== undefined && isWalletAssetAvailable(recalculatedAsset) ? this.selectWalletAsset(assetId, {
       selected: true,
-      source: "scan"
+      source: 'scan'
     }) : recalculatedState;
-    const isSelected = assetId !== void 0 && selected.selectedIds.some((id) => String(id) === String(assetId));
-    const selectedStateAsset = assetId === void 0 ? void 0 : selected.items.find(
-      (item) => getWalletAssetKey(item) === String(assetId)
-    );
+    const isSelected = assetId !== undefined && selected.selectedIds.some(id => String(id) === String(assetId));
+    const selectedStateAsset = assetId === undefined ? undefined : selected.items.find(item => getWalletAssetKey(item) === String(assetId));
     const resolvedAsset = selectedStateAsset || recalculatedAsset || asset;
     if (isSelected) {
       this.clearPendingAutoSelectForAsset(resolvedAsset);
     } else if (this.walletAssetsBehavior.autoSelectAfterSearch) {
-      this.pendingAutoSelectSearchCodes.add(
-        normalizeWalletAssetCode(normalizedCode)
-      );
+      this.pendingAutoSelectSearchCodes.add(normalizeWalletAssetCode(normalizedCode));
       this.queuePendingAutoSelectForAssets([resolvedAsset]);
     }
     return {
@@ -1324,58 +1158,41 @@ var WalletPassPaymentImpl = class {
   }
   clearWalletAssetSelection() {
     this.pendingAutoSelectSearchCodes.clear();
-    const selectedKeys = new Set(
-      this.walletAssetsState.selectedIds.map((id) => String(id))
-    );
-    const clearSelectedEditAmount = (asset) => selectedKeys.has(getWalletAssetKey(asset)) ? { ...asset, edit_current_amount: void 0 } : asset;
-    this.searchResults = this.searchResults.map(
-      clearSelectedEditAmount
-    );
-    return this.recalculateWalletAssets(
-      this.walletAssetsState.items.map(clearSelectedEditAmount),
-      [],
-      {}
-    );
+    const selectedKeys = new Set(this.walletAssetsState.selectedIds.map(id => String(id)));
+    const clearSelectedEditAmount = asset => selectedKeys.has(getWalletAssetKey(asset)) ? {
+      ...asset,
+      edit_current_amount: undefined
+    } : asset;
+    this.searchResults = this.searchResults.map(clearSelectedEditAmount);
+    return this.recalculateWalletAssets(this.walletAssetsState.items.map(clearSelectedEditAmount), [], {});
   }
   setCommittedWalletAssets(committedIds, committedAssets = []) {
-    const committedKeys = new Set(committedIds.map((id) => String(id)));
-    const selectedIds = this.walletAssetsState.selectedIds.filter(
-      (id) => !committedKeys.has(String(id))
-    );
-    const selectionSources = Object.entries(
-      this.walletAssetsState.selectionSources
-    ).reduce(
-      (result, [key, source]) => {
-        if (!committedKeys.has(key))
-          result[key] = source;
-        return result;
-      },
-      {}
-    );
+    const committedKeys = new Set(committedIds.map(id => String(id)));
+    const selectedIds = this.walletAssetsState.selectedIds.filter(id => !committedKeys.has(String(id)));
+    const selectionSources = Object.entries(this.walletAssetsState.selectionSources).reduce((result, [key, source]) => {
+      if (!committedKeys.has(key)) result[key] = source;
+      return result;
+    }, {});
     this.publishWalletAssetsState({
       items: mergeWalletAssets(this.walletAssetsState.items, committedAssets),
       committedIds
     });
-    return this.recalculateWalletAssets(
-      this.walletAssetsState.items,
-      selectedIds,
-      selectionSources
-    );
+    return this.recalculateWalletAssets(this.walletAssetsState.items, selectedIds, selectionSources);
   }
   async processWalletPayment(amount, orderUuid, voucherId) {
-    this.paymentModule.logInfo("[WalletPass] 开始处理钱包支付", {
-      amount,
-      orderUuid,
-      voucherId: voucherId || "none"
+    this.paymentModule.logInfo('[WalletPass] 开始处理钱包支付', {
+      amount: amount,
+      orderUuid: orderUuid,
+      voucherId: voucherId || 'none'
     });
     const walletMethod = await this.paymentModule.getWalletPaymentMethod();
     if (!walletMethod) {
-      this.paymentModule.logError("[WalletPass] 钱包支付方式未找到", null, {
-        amount,
-        orderUuid,
-        voucherId
+      this.paymentModule.logError('[WalletPass] 钱包支付方式未找到', null, {
+        amount: amount,
+        orderUuid: orderUuid,
+        voucherId: voucherId
       });
-      throw new Error("钱包支付方式未找到");
+      throw new Error('钱包支付方式未找到');
     }
     const paymentItem = {
       amount: amount.toString(),
@@ -1383,84 +1200,99 @@ var WalletPassPaymentImpl = class {
       custom_payment_id: walletMethod.id,
       name: walletMethod.name,
       type: walletMethod.type,
-      voucher_id: voucherId || ""
+      voucher_id: voucherId || ''
     };
     await this.paymentModule.addPaymentItemAsync(orderUuid, paymentItem);
-    this.paymentModule.logInfo("[WalletPass] 钱包支付处理完成", {
-      amount,
-      orderUuid,
-      voucherId: voucherId || "none",
+    this.paymentModule.logInfo('[WalletPass] 钱包支付处理完成', {
+      amount: amount,
+      orderUuid: orderUuid,
+      voucherId: voucherId || 'none',
       payment_method: walletMethod.name
     });
   }
   async getWalletBalance(voucherId) {
+    // 获取钱包余额的逻辑
     return 0;
   }
+
   /**
    * 获取缓存的钱包推荐列表
    */
   getWalletRecommendList() {
     return this.walletRecommendList;
   }
+
   /**
    * 获取缓存的用户识别码列表
    */
   getUserIdentificationCodes() {
     return this.userIdentificationCodes;
   }
+
   /**
    * 清除钱包推荐列表
    */
   clearWalletRecommendList() {
     this.walletRecommendList = [];
-    this.emitEvent(import_types.WalletPassHooks.OnWalletRecommendListCleared, {
-      clearedTypes: ["walletRecommendList"]
+
+    // 发送钱包推荐列表清除事件
+    this.emitEvent(_types.WalletPassHooks.OnWalletRecommendListCleared, {
+      clearedTypes: ['walletRecommendList']
     });
-    this.paymentModule.logInfo("[WalletPass] 钱包推荐列表已清除");
+    this.paymentModule.logInfo('[WalletPass] 钱包推荐列表已清除');
   }
+
   /**
    * 清除用户识别码列表
    */
   clearUserIdentificationCodes() {
     this.userIdentificationCodes = [];
-    this.emitEvent(import_types.WalletPassHooks.OnUserIdentificationCodesCleared, {
-      clearedTypes: ["userIdentificationCodes"]
+
+    // 发送用户识别码列表清除事件
+    this.emitEvent(_types.WalletPassHooks.OnUserIdentificationCodesCleared, {
+      clearedTypes: ['userIdentificationCodes']
     });
-    this.paymentModule.logInfo("[WalletPass] 用户识别码列表已清除");
+    this.paymentModule.logInfo('[WalletPass] 用户识别码列表已清除');
   }
+
   /**
    * 获取缓存的搜索结果列表
    */
   getSearchResults() {
     return this.searchResults;
   }
+
   /**
    * 根据识别码查找搜索结果
    */
   findSearchResultByCode(code) {
-    return this.searchResults.find((item) => item.code === code);
+    return this.searchResults.find(item => item.code === code);
   }
+
   /**
    * 清除搜索结果缓存
    */
   clearSearchResults() {
     this.searchResults = [];
     this.pendingAutoSelectSearchCodes.clear();
-    this.paymentModule.logInfo("[WalletPass] 搜索结果缓存已清除");
+    this.paymentModule.logInfo('[WalletPass] 搜索结果缓存已清除');
   }
+
   /**
    * 获取存储的钱包初始化数据
    */
   getStoredWalletInitData() {
     return this.walletInitData;
   }
+
   /**
    * 清除存储的钱包初始化数据
    */
   clearStoredWalletInitData() {
     this.walletInitData = null;
-    this.paymentModule.logInfo("[WalletPass] 钱包初始化数据已清除");
+    this.paymentModule.logInfo('[WalletPass] 钱包初始化数据已清除');
   }
+
   /**
    * 清除所有缓存数据
    */
@@ -1478,21 +1310,14 @@ var WalletPassPaymentImpl = class {
     };
     this.walletAssetsState = createInitialWalletAssetsState();
     this.publishWalletAssetsState({});
-    this.emitEvent(import_types.WalletPassHooks.OnWalletCacheCleared, {
-      clearedTypes: ["all"]
+
+    // 发送所有缓存清除事件
+    this.emitEvent(_types.WalletPassHooks.OnWalletCacheCleared, {
+      clearedTypes: ['all']
     });
-    this.paymentModule.logInfo("[WalletPass] 所有缓存数据已清除", {
-      cleared_types: [
-        "walletRecommendList",
-        "userIdentificationCodes",
-        "searchResults",
-        "walletParams",
-        "walletInitData"
-      ]
+    this.paymentModule.logInfo('[WalletPass] 所有缓存数据已清除', {
+      cleared_types: ['walletRecommendList', 'userIdentificationCodes', 'searchResults', 'walletParams', 'walletInitData']
     });
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WalletPassPaymentImpl
-});
+}
+exports.WalletPassPaymentImpl = WalletPassPaymentImpl;