diff --git a/distribution/withdraw/index.vue b/distribution/withdraw/index.vue
index cbce567..2144a48 100644
--- a/distribution/withdraw/index.vue
+++ b/distribution/withdraw/index.vue
@@ -91,6 +91,10 @@
 <script setup>
 import * as distributionApi from "@/common/api/market/distribution.js";
 import { productStore } from "@/stores/user.js";
+import {
+	APIuserlogin,
+	APIuser
+} from "@/common/api/api.js";
 const storeuser = productStore();
 import { ref, onMounted, reactive } from "vue";
 import { onLoad, onReachBottom, onShow } from "@dcloudio/uni-app";
@@ -222,7 +226,7 @@ onLoad(() => {
 });
 
 onShow(() => {
-  storeuser.actionsAPIuser().then((res) => {
+ APIuser.then((res) => {
     userinfo.value = res;
   });
 });
diff --git a/lib/goods.ts b/lib/goods.ts
index 4b73719..2ffb7cc 100644
--- a/lib/goods.ts
+++ b/lib/goods.ts
@@ -2,8 +2,8 @@ import { BigNumber } from "bignumber.js";
 
 // 配置BigNumber精度
 BigNumber.set({
-  DECIMAL_PLACES: 2,
-  ROUNDING_MODE: BigNumber.ROUND_DOWN, // 向下取整，符合业务需求
+	DECIMAL_PLACES: 2,
+	ROUNDING_MODE: BigNumber.ROUND_DOWN, // 向下取整，符合业务需求
 });
 /**
  * 购物车订单价格计算公共库
@@ -20,26 +20,26 @@ BigNumber.set({
  */
 
 import {
-  Coupon,
-  GoodsType,
-  BackendCoupon,
-  ExchangeCalculationResult,
-  PointDeductionRule,
-  ShopUserInfo,
-  OrderCostSummary,
-  CouponResult,
-  SeatFeeConfig,
-  FullReductionActivity,
-  BaseCartItem,
-  TimeLimitDiscountConfig,
-  BaseCoupon,
-  OrderExtraConfig,
-  ActivityConfig,
-  FullReductionThreshold,
-  CouponType,
-  ActivityType,
-  MerchantReductionType,
-  WEEKDAY_MAP,
+	Coupon,
+	GoodsType,
+	BackendCoupon,
+	ExchangeCalculationResult,
+	PointDeductionRule,
+	ShopUserInfo,
+	OrderCostSummary,
+	CouponResult,
+	SeatFeeConfig,
+	FullReductionActivity,
+	BaseCartItem,
+	TimeLimitDiscountConfig,
+	BaseCoupon,
+	OrderExtraConfig,
+	ActivityConfig,
+	FullReductionThreshold,
+	CouponType,
+	ActivityType,
+	MerchantReductionType,
+	WEEKDAY_MAP,
 } from "./types";
 
 /**
@@ -49,30 +49,30 @@ import {
  * @returns 是否在时段内
  */
 function isInDailyTimeRange(
-  activity: FullReductionActivity,
-  currentTime: Date
-): boolean {
-  // 全时段无需校验
-  if (activity.useTimeType === "all") return true;
-  // 无时段配置则不通过
-  if (!activity.useStartTime || !activity.useEndTime) return false;
+	activity : FullReductionActivity,
+	currentTime : Date
+) : boolean {
+	// 全时段无需校验
+	if (activity.useTimeType === "all") return true;
+	// 无时段配置则不通过
+	if (!activity.useStartTime || !activity.useEndTime) return false;
 
-  const [startHour, startMinute] = activity.useStartTime.split(":").map(Number);
-  const [endHour, endMinute] = activity.useEndTime.split(":").map(Number);
-  const currentHour = currentTime.getHours();
-  const currentMinute = currentTime.getMinutes();
+	const [startHour, startMinute] = activity.useStartTime.split(":").map(Number);
+	const [endHour, endMinute] = activity.useEndTime.split(":").map(Number);
+	const currentHour = currentTime.getHours();
+	const currentMinute = currentTime.getMinutes();
 
-  // 转换为分钟数比较
-  const startTotalMin = startHour * 60 + startMinute;
-  const endTotalMin = endHour * 60 + endMinute;
-  const currentTotalMin = currentHour * 60 + currentMinute;
+	// 转换为分钟数比较
+	const startTotalMin = startHour * 60 + startMinute;
+	const endTotalMin = endHour * 60 + endMinute;
+	const currentTotalMin = currentHour * 60 + currentMinute;
 
-  // 处理跨天场景（如23:00-02:00）
-  if (startTotalMin <= endTotalMin) {
-    return currentTotalMin >= startTotalMin && currentTotalMin <= endTotalMin;
-  } else {
-    return currentTotalMin >= startTotalMin || currentTotalMin <= endTotalMin;
-  }
+	// 处理跨天场景（如23:00-02:00）
+	if (startTotalMin <= endTotalMin) {
+		return currentTotalMin >= startTotalMin && currentTotalMin <= endTotalMin;
+	} else {
+		return currentTotalMin >= startTotalMin || currentTotalMin <= endTotalMin;
+	}
 }
 
 /**
@@ -82,16 +82,16 @@ function isInDailyTimeRange(
  * @returns 是否在周期内
  */
 function isInWeeklyCycle(
-  activity: FullReductionActivity,
-  currentTime: Date
-): boolean {
-  // 无周期配置则不通过
-  if (!activity.useDays) return false;
-  const currentWeekday = currentTime.getDay(); // 0=周日，1=周一...6=周六
-  const allowedWeekdays = activity.useDays
-    .split(",")
-    .map((day) => WEEKDAY_MAP[day as keyof typeof WEEKDAY_MAP]);
-  return allowedWeekdays.includes(currentWeekday);
+	activity : FullReductionActivity,
+	currentTime : Date
+) : boolean {
+	// 无周期配置则不通过
+	if (!activity.useDays) return false;
+	const currentWeekday = currentTime.getDay(); // 0=周日，1=周一...6=周六
+	const allowedWeekdays = activity.useDays
+		.split(",")
+		.map((day) => WEEKDAY_MAP[day as keyof typeof WEEKDAY_MAP]);
+	return allowedWeekdays.includes(currentWeekday);
 }
 
 /**
@@ -101,122 +101,103 @@ function isInWeeklyCycle(
  * @returns 是否匹配
  */
 function isDinnerTypeMatch(
-  activity: FullReductionActivity,
-  currentDinnerType: string
-): boolean {
-  if (!activity.useType) return false;
-  const allowedTypes = activity.useType.split(",");
-  //满减活动的就餐类型和当前券类型字段值不一样，暂时返回true
-  return true;
+	activity : FullReductionActivity,
+	currentDinnerType : string
+) : boolean {
+	if (!activity.useType) return false;
+	const allowedTypes = activity.useType.split(",");
+	//满减活动的就餐类型和当前券类型字段值不一样，暂时返回true
+	return true;
 }
 
 //判断商品是否可以使用限时折扣
 export function returnCanUseLimitTimeDiscount(
-  goods: BaseCartItem,
-  limitTimeDiscount: TimeLimitDiscountConfig | null | undefined,
-  useVipPrice: boolean,
-  idKey = "product_id"
+	goods : BaseCartItem,
+	limitTimeDiscount : TimeLimitDiscountConfig | null | undefined,
+	useVipPrice : boolean,
+	idKey = "product_id"
 ) {
-  goods={...goods,product_id:goods.product_id||goods.productId|| goods.id|| ''}
-  if (!limitTimeDiscount || !limitTimeDiscount.id) {
-    return false;
-  }
-  const canUseFoods = (limitTimeDiscount.foods || "").split(",");
-  const goodsCanUse =
-    limitTimeDiscount.foodType == 1 ||
-    canUseFoods.includes("" + goods[idKey as keyof BaseCartItem]);
-  if (!goodsCanUse) {
-    return false;
-  }
-  if (limitTimeDiscount.discountPriority == "limit-time") {
-    return true;
-  }
-  if (limitTimeDiscount.discountPriority == "vip-price") {
-    if (!useVipPrice) {
-      return true;
-    }
-    if (useVipPrice && goods.hasOwnProperty("memberPrice")) {
+	goods = { ...goods, product_id: goods.product_id || goods.productId || goods.id || '' }
+	if (!limitTimeDiscount || !limitTimeDiscount.id) {
+		return false;
+	}
+	const canUseFoods = (limitTimeDiscount.foods || "").split(",");
+	const goodsCanUse =
+		limitTimeDiscount.foodType == 1 ||
+		canUseFoods.includes("" + goods[idKey as keyof BaseCartItem]);
+	if (!goodsCanUse) {
+		return false;
+	}
+	if (limitTimeDiscount.discountPriority == "limit-time") {
+		return true;
+	}
+	if (limitTimeDiscount.discountPriority == "vip-price") {
+		if (!useVipPrice) {
+			return true;
+		}
+		if (useVipPrice && goods.hasOwnProperty("memberPrice")) {
 
-      if ( goods.memberPrice * 1 <= 0) {
+			if (goods.memberPrice * 1 <= 0) {
 
-        return true;
-      }else{
-        return false;
-      }
-    }
-  }
+				return true;
+			} else {
+				return false;
+			}
+		}
+	}
 
-  return false;
+	return false;
 }
 
-function returnMemberPrice(useVipPrice: boolean, goods: BaseCartItem) {
-  if (useVipPrice) {
-    return goods.memberPrice || goods.salePrice;
-  } else {
-    return goods.salePrice;
-  }
+function returnMemberPrice(useVipPrice : boolean, goods : BaseCartItem) {
+	if (useVipPrice) {
+		return goods.memberPrice || goods.salePrice;
+	} else {
+		return goods.salePrice;
+	}
 }
 
 /**
  * 返回商品限时折扣价格
  */
 function returnLimitPrice(
-  goods: BaseCartItem,
-  limitTimeDiscount: TimeLimitDiscountConfig | null | undefined,
-  useVipPrice: boolean
+	goods : BaseCartItem,
+	limitTimeDiscount : TimeLimitDiscountConfig | null | undefined,
+	useVipPrice : boolean
 ) {
-  if (!limitTimeDiscount) {
-    return 0;
-  }
-  const discountRate = new BigNumber(limitTimeDiscount.discountRate).dividedBy(
-    100
-  );
-  let canuseLimit=false;
-  if(goods.hasOwnProperty('isTimeDiscount')||goods.hasOwnProperty('is_time_discount')){
-    canuseLimit=goods.isTimeDiscount?true:goods.is_time_discount?true:false;
-  }else{
-    canuseLimit = returnCanUseLimitTimeDiscount(
-      goods,
-      limitTimeDiscount,
-      useVipPrice
-    );
-  }
+	if (!limitTimeDiscount) {
+		return 0;
+	}
+	const discountRate = new BigNumber(limitTimeDiscount.discountRate).dividedBy(
+		100
+	);
+	let canuseLimit = false;
+	if (goods.hasOwnProperty('isTimeDiscount') || goods.hasOwnProperty('is_time_discount')) {
+		canuseLimit = goods.isTimeDiscount ? true : goods.is_time_discount ? true : false;
+	} else {
+		canuseLimit = returnCanUseLimitTimeDiscount(
+			goods,
+			limitTimeDiscount,
+			useVipPrice
+		);
+	}
 
-  if (canuseLimit) {
-    //可以使用限时折扣
-    if (limitTimeDiscount.discountPriority == "limit-time") {
-      //限时价优先
-      const result = BigNumber(goods.salePrice)
-        .times(discountRate)
-        .decimalPlaces(2, BigNumber.ROUND_UP)
-        .toNumber();
-      return result;
-    }
-    if (limitTimeDiscount.discountPriority == "vip-price") {
 
-      //会员价优先
-      if (useVipPrice && goods.memberPrice && goods.memberPrice * 1 > 0) {
-        //使用会员价
-        return returnMemberPrice(useVipPrice, goods);
-      } else {
-        //不使用会员价
-        const result = BigNumber(goods.salePrice)
-          .times(discountRate)
-          .decimalPlaces(2, BigNumber.ROUND_UP)
-          .toNumber();
-        return result;
-      }
-    }
-  } else {
-    //不可以使用限时折扣
-    //会员价优先
-    if (useVipPrice) {
-      //使用会员价
-      return returnMemberPrice(useVipPrice, goods);
-    } else {
-      return goods.salePrice;
-    }
-  }
+	if (canuseLimit) {
+		//可以使用限时折扣
+		const result = BigNumber(goods.salePrice)
+			.times(discountRate)
+			.decimalPlaces(2, BigNumber.ROUND_UP)
+			.toNumber();
+		return result;
+	}
+	//会员价优先
+	if (useVipPrice) {
+		//使用会员价
+		return returnMemberPrice(useVipPrice, goods);
+	} else {
+		return goods.salePrice;
+	}
 }
 
 /**
@@ -224,89 +205,91 @@ function returnLimitPrice(
  */
 
 export function returnCalcPrice(
-  goods: BaseCartItem,
-  fullReductionActivitie: FullReductionActivity | undefined,
-  limitTimeDiscount: TimeLimitDiscountConfig | null | undefined,
-  useVipPrice: boolean,
-  idKey = "product_id"
+	goods : BaseCartItem,
+	fullReductionActivitie : FullReductionActivity | undefined,
+	limitTimeDiscount : TimeLimitDiscountConfig | null | undefined,
+	useVipPrice : boolean,
+	idKey = "product_id"
 ) {
-  if (goods.discountSaleAmount && goods.discountSaleAmount * 1 > 0) {
-    return goods.salePrice;
-  }
-  //限时折扣和满减活动都有
-  if (fullReductionActivitie && limitTimeDiscount) {
-    if (
-      fullReductionActivitie.discountShare == 1 &&
-      fullReductionActivitie.vipPriceShare == 1
-    ) {
-      //与限时折扣同享，与会员价同享
-      return returnLimitPrice(goods, limitTimeDiscount, useVipPrice);
-    }
-    if (
-      fullReductionActivitie.discountShare != 1 &&
-      fullReductionActivitie.vipPriceShare == 1
-    ) {
-      //与限时折扣不同享，与会员价同享
-      return returnMemberPrice(useVipPrice, goods);
-    }
-    if (fullReductionActivitie.vipPriceShare != 1) {
-      //与会员价不同享
-      return goods.salePrice;
-    }
-    return goods.salePrice;
-  }
-  //只有满减活动
-  if (fullReductionActivitie) {
-    if (fullReductionActivitie.vipPriceShare == 1) {
-      return returnMemberPrice(useVipPrice, goods);
-    } else {
-      return goods.salePrice;
-    }
-  }
-  //只有限时折扣
-  if (limitTimeDiscount) {
-    return returnLimitPrice(goods, limitTimeDiscount, useVipPrice);
-  }
+	if (goods.discountSaleAmount && goods.discountSaleAmount * 1 > 0) {
+		return goods.salePrice;
+	}
+	//限时折扣和满减活动都有
+	if (fullReductionActivitie && limitTimeDiscount) {
+		if (
+			fullReductionActivitie.discountShare == 1 &&
+			fullReductionActivitie.vipPriceShare == 1
+		) {
+			//与限时折扣同享，与会员价同享
+			return returnLimitPrice(goods, limitTimeDiscount, useVipPrice);
+		}
+		if (
+			fullReductionActivitie.discountShare != 1 &&
+			fullReductionActivitie.vipPriceShare == 1
+		) {
+			//与限时折扣不同享，与会员价同享
+			return returnMemberPrice(useVipPrice, goods);
+		}
+		if (fullReductionActivitie.vipPriceShare != 1) {
+			//与会员价不同享
+			return goods.salePrice;
+		}
+		return goods.salePrice;
+	}
+	//只有满减活动
+	if (fullReductionActivitie) {
+		if (fullReductionActivitie.vipPriceShare == 1) {
+			return returnMemberPrice(useVipPrice, goods);
+		} else {
+			return goods.salePrice;
+		}
+	}
+	//只有限时折扣
+	if (limitTimeDiscount) {
+		return returnLimitPrice(goods, limitTimeDiscount, useVipPrice);
+	}
 
-  if (useVipPrice) {
-    return returnMemberPrice(useVipPrice, goods);
-  }
-  return goods.salePrice;
+	if (useVipPrice) {
+		return returnMemberPrice(useVipPrice, goods);
+	}
+	return goods.salePrice;
 }
 
 /**
  * 计算满减活动门槛
  */
 export function calcFullReductionActivityFullAmount(
-  goodsList: BaseCartItem[],
-  fullReductionActivitie: FullReductionActivity | undefined,
-  limitTimeDiscount: TimeLimitDiscountConfig | null | undefined,
-  useVipPrice: boolean,
-  seatFee: number,
-  packFee: number
-): number {
-  if (!fullReductionActivitie) {
-    return 0;
-  }
-  let amount = 0;
-  for (let goods of goodsList) {
-    const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
-    if (goods.is_temporary ||goods.isTemporary || goods.is_gift ||goods.isGift  || availableNum <= 0) {
-      //临时菜，赠菜，数量<=0的商品不计算
-      continue;
-    }
-    const calcPrice = returnCalcPrice(
-      goods,
-      fullReductionActivitie,
-      limitTimeDiscount,
-      useVipPrice,
-      "product_id"
-    );
-    if (calcPrice !== undefined) {
-      amount += calcPrice * availableNum;
-    }
-  }
-  return amount + seatFee + packFee;
+	goodsList : BaseCartItem[],
+	fullReductionActivitie : FullReductionActivity | undefined,
+	limitTimeDiscount : TimeLimitDiscountConfig | null | undefined,
+	useVipPrice : boolean,
+	seatFee : number,
+	packFee : number
+) : number {
+	if (!fullReductionActivitie) {
+		return 0;
+	}
+	let amount = 0;
+	for (let goods of goodsList) {
+		const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
+		if (goods.is_temporary || goods.isTemporary || goods.is_gift || goods.isGift || availableNum <= 0) {
+			//临时菜，赠菜，数量<=0的商品不计算
+			continue;
+		}
+		const calcPrice = returnCalcPrice(
+			goods,
+			fullReductionActivitie,
+			limitTimeDiscount,
+			useVipPrice,
+			"product_id"
+		);
+		console.log('calcPrice', calcPrice);
+		console.log('goods', goods);
+		if (calcPrice !== undefined) {
+			amount += calcPrice * availableNum;
+		}
+	}
+	return amount + seatFee + packFee;
 }
 
 /**
@@ -318,70 +301,70 @@ export function calcFullReductionActivityFullAmount(
  * @returns 最优满减活动（无符合条件则返回undefined）
  */
 export function filterOptimalFullReductionActivity(
-  activities: FullReductionActivity[],
-  currentShopId: number,
-  currentDinnerType: string,
-  currentTime: Date = new Date()
-): FullReductionActivity | undefined {
-  if (!activities || !activities.length) return undefined;
-  // 第一步：基础筛选（未删除+当前店铺+活动进行中+就餐类型匹配）
-  const baseEligible = activities.filter((activity) => {
-    return (
-      // activity.isDel !== true && // 未删除
-      // activity.shopId === currentShopId && // 当前店铺
-      // activity.status === 2 && // 状态=2（进行中）
-      isDinnerTypeMatch(activity, currentDinnerType) && // 就餐类型匹配
-      activity.thresholds?.length // 至少有一个满减阈值
-    );
-  });
+	activities : FullReductionActivity[],
+	currentShopId : number,
+	currentDinnerType : string,
+	currentTime : Date = new Date()
+) : FullReductionActivity | undefined {
+	if (!activities || !activities.length) return undefined;
+	// 第一步：基础筛选（未删除+当前店铺+活动进行中+就餐类型匹配）
+	const baseEligible = activities.filter((activity) => {
+		return (
+			// activity.isDel !== true && // 未删除
+			// activity.shopId === currentShopId && // 当前店铺
+			// activity.status === 2 && // 状态=2（进行中）
+			isDinnerTypeMatch(activity, currentDinnerType) && // 就餐类型匹配
+			activity.thresholds?.length // 至少有一个满减阈值
+		);
+	});
 
-  if (!baseEligible.length) return undefined;
+	if (!baseEligible.length) return undefined;
 
-  // 第二步：时间筛选（有效期内+周期内+时段内）
-  const timeEligible = baseEligible.filter((activity) => {
-    // 1. 校验有效期（validStartTime ~ validEndTime）
-    if (activity.useTimeType == "all") {
-      return true;
-    }
-    if (!activity.validStartTime || !activity.validEndTime) return false;
-    const startDate = new Date(activity.validStartTime);
-    const endDate = new Date(activity.validEndTime);
-    // 处理有效期结束日期的23:59:59
-    endDate.setHours(23, 59, 59, 999);
-    if (currentTime < startDate || currentTime > endDate) return false;
+	// 第二步：时间筛选（有效期内+周期内+时段内）
+	const timeEligible = baseEligible.filter((activity) => {
+		// 1. 校验有效期（validStartTime ~ validEndTime）
+		if (activity.useTimeType == "all") {
+			return true;
+		}
+		if (!activity.validStartTime || !activity.validEndTime) return false;
+		const startDate = new Date(activity.validStartTime);
+		const endDate = new Date(activity.validEndTime);
+		// 处理有效期结束日期的23:59:59
+		endDate.setHours(23, 59, 59, 999);
+		if (currentTime < startDate || currentTime > endDate) return false;
 
-    // 2. 校验可用周期（如周一至周日）
-    if (!isInWeeklyCycle(activity, currentTime)) return false;
+		// 2. 校验可用周期（如周一至周日）
+		if (!isInWeeklyCycle(activity, currentTime)) return false;
 
-    // 3. 校验每日可用时段（如09:00-22:00）
-    if (!isInDailyTimeRange(activity, currentTime)) return false;
+		// 3. 校验每日可用时段（如09:00-22:00）
+		if (!isInDailyTimeRange(activity, currentTime)) return false;
 
-    return true;
-  });
+		return true;
+	});
 
-  if (!timeEligible.length) return undefined;
+	if (!timeEligible.length) return undefined;
 
-  // 第三步：按优先级排序（需求规则）
-  return timeEligible.sort((a, b) => {
-    // 1. 先比排序值：排序值大的优先
-    if ((a.sort || 0) !== (b.sort || 0)) {
-      return (b.sort || 0) - (a.sort || 0);
-    }
-    // 2. 再比修改时间：最新修改的优先（时间戳降序）
-    const aUpdateTime = a.updateTime ? new Date(a.updateTime).getTime() : 0;
-    const bUpdateTime = b.updateTime ? new Date(b.updateTime).getTime() : 0;
-    return bUpdateTime - aUpdateTime;
-  })[0]; // 取最优活动
+	// 第三步：按优先级排序（需求规则）
+	return timeEligible.sort((a, b) => {
+		// 1. 先比排序值：排序值大的优先
+		if ((a.sort || 0) !== (b.sort || 0)) {
+			return (b.sort || 0) - (a.sort || 0);
+		}
+		// 2. 再比修改时间：最新修改的优先（时间戳降序）
+		const aUpdateTime = a.updateTime ? new Date(a.updateTime).getTime() : 0;
+		const bUpdateTime = b.updateTime ? new Date(b.updateTime).getTime() : 0;
+		return bUpdateTime - aUpdateTime;
+	})[0]; // 取最优活动
 }
 /**
  * 折扣率格式化：后端discountRate（%）→ 工具库小数（如90→0.9）
  */
-export function formatDiscountRate(backendDiscountRate?: number): number {
-  if (!backendDiscountRate || backendDiscountRate <= 0) return 1; // 默认无折扣（1=100%）
-  // 后端若为百分比（如90=9折），除以100；若已为小数（如0.9）直接返回
-  return backendDiscountRate >= 1
-    ? backendDiscountRate / 100
-    : backendDiscountRate;
+export function formatDiscountRate(backendDiscountRate ?: number) : number {
+	if (!backendDiscountRate || backendDiscountRate <= 0) return 1; // 默认无折扣（1=100%）
+	// 后端若为百分比（如90=9折），除以100；若已为小数（如0.9）直接返回
+	return backendDiscountRate >= 1
+		? backendDiscountRate / 100
+		: backendDiscountRate;
 }
 
 /**
@@ -390,8 +373,8 @@ export function formatDiscountRate(backendDiscountRate?: number): number {
  * @param num 待处理数字
  * @returns 处理后保留两位小数的数字
  */
-export function truncateToTwoDecimals(num: number | string): number {
-  return new BigNumber(num).decimalPlaces(2, BigNumber.ROUND_DOWN).toNumber();
+export function truncateToTwoDecimals(num : number | string) : number {
+	return new BigNumber(num).decimalPlaces(2, BigNumber.ROUND_DOWN).toNumber();
 }
 
 /**
@@ -399,8 +382,8 @@ export function truncateToTwoDecimals(num: number | string): number {
  * @param goods 商品项
  * @returns 是否临时菜
  */
-export function isTemporaryGoods(goods: BaseCartItem): boolean {
-  return !!goods.is_temporary|| !!goods.isTemporary;
+export function isTemporaryGoods(goods : BaseCartItem) : boolean {
+	return !!goods.is_temporary || !!goods.isTemporary;
 }
 
 /**
@@ -408,15 +391,15 @@ export function isTemporaryGoods(goods: BaseCartItem): boolean {
  * @param goods 商品项
  * @returns 是否赠菜
  */
-export function isGiftGoods(goods: BaseCartItem): boolean {
-  return !!goods.is_gift || !!goods.isGift;
+export function isGiftGoods(goods : BaseCartItem) : boolean {
+	return !!goods.is_gift || !!goods.isGift;
 }
 /**
  * 判断可用类型是否可用
  */
-export function useTypeCanUse(useType: string[]) {
-  const arr = ["all", "dine-in", "take-out", "take-away", "post"];
-  return useType.some((item) => arr.includes(item));
+export function useTypeCanUse(useType : string[]) {
+	const arr = ["all", "dine-in", "take-out", "take-away", "post"];
+	return useType.some((item) => arr.includes(item));
 }
 
 /**
@@ -427,22 +410,22 @@ export function useTypeCanUse(useType: string[]) {
  * @returns 会员价（元）
  */
 export function calcMemberPrice(
-  goods: BaseCartItem,
-  isMember: boolean,
-  memberDiscountRate?: number
-): number {
-  if (!isMember) return truncateToTwoDecimals(goods.salePrice);
+	goods : BaseCartItem,
+	isMember : boolean,
+	memberDiscountRate ?: number
+) : number {
+	if (!isMember) return truncateToTwoDecimals(goods.salePrice);
 
-  // 优先级：SKU会员价 > 商品会员价 > 商品原价（无会员价时用会员折扣）
-  const basePrice = goods.memberPrice || goods.salePrice;
-  // 仅当无SKU会员价、无商品会员价时，才应用会员折扣率
-  if (memberDiscountRate && !goods.skuData?.memberPrice && !goods.memberPrice) {
-    return truncateToTwoDecimals(
-      new BigNumber(basePrice).multipliedBy(memberDiscountRate).toNumber()
-    );
-  }
+	// 优先级：SKU会员价 > 商品会员价 > 商品原价（无会员价时用会员折扣）
+	const basePrice = goods.memberPrice || goods.salePrice;
+	// 仅当无SKU会员价、无商品会员价时，才应用会员折扣率
+	if (memberDiscountRate && !goods.skuData?.memberPrice && !goods.memberPrice) {
+		return truncateToTwoDecimals(
+			new BigNumber(basePrice).multipliedBy(memberDiscountRate).toNumber()
+		);
+	}
 
-  return truncateToTwoDecimals(basePrice);
+	return truncateToTwoDecimals(basePrice);
 }
 
 /**
@@ -452,15 +435,15 @@ export function calcMemberPrice(
  * @returns 可参与优惠券计算的商品列表
  */
 export function filterCouponEligibleGoods(
-  goodsList: BaseCartItem[],
-  excludedProductIds: string[] = []
-): BaseCartItem[] {
-  return goodsList.filter(
-    (goods) =>
-      !isTemporaryGoods(goods) &&
-      !isGiftGoods(goods) &&
-      !excludedProductIds.includes(String(goods.product_id)) // 核心修正：用商品ID排除
-  );
+	goodsList : BaseCartItem[],
+	excludedProductIds : string[] = []
+) : BaseCartItem[] {
+	return goodsList.filter(
+		(goods) =>
+			!isTemporaryGoods(goods) &&
+			!isGiftGoods(goods) &&
+			!excludedProductIds.includes(String(goods.product_id)) // 核心修正：用商品ID排除
+	);
 }
 
 /**
@@ -470,15 +453,15 @@ export function filterCouponEligibleGoods(
  * @returns 最终参与优惠券计算的商品列表
  */
 export function filterThresholdGoods(
-  baseEligibleGoods: BaseCartItem[],
-  applicableProductIds: string[]
-): BaseCartItem[] {
-  // 空数组=全部基础合格商品；非空=仅商品ID匹配的商品（转字符串兼容类型）
-  return applicableProductIds.length === 0
-    ? baseEligibleGoods
-    : baseEligibleGoods.filter((goods) =>
-        applicableProductIds.includes(String(goods.product_id))
-      ); // 核心修正：用商品ID匹配
+	baseEligibleGoods : BaseCartItem[],
+	applicableProductIds : string[]
+) : BaseCartItem[] {
+	// 空数组=全部基础合格商品；非空=仅商品ID匹配的商品（转字符串兼容类型）
+	return applicableProductIds.length === 0
+		? baseEligibleGoods
+		: baseEligibleGoods.filter((goods) =>
+			applicableProductIds.includes(String(goods.product_id))
+		); // 核心修正：用商品ID匹配
 }
 
 /**
@@ -489,28 +472,28 @@ export function filterThresholdGoods(
  * @returns 排序后的商品列表
  */
 export function sortGoodsForCoupon(
-  goodsList: BaseCartItem[],
-  sortRule: "low_price_first" | "high_price_first",
-  cartOrder: Record<string, number> = {}
-): BaseCartItem[] {
-  return [...goodsList].sort((a, b) => {
-    // 1. 按商品单价排序（优先级最高）
-    const priceA = a.skuData?.salePrice ?? a.salePrice;
-    const priceB = b.skuData?.salePrice ?? b.salePrice;
-    if (priceA !== priceB) {
-      return sortRule === "low_price_first" ? priceA - priceB : priceB - priceA;
-    }
+	goodsList : BaseCartItem[],
+	sortRule : "low_price_first" | "high_price_first",
+	cartOrder : Record<string, number> = {}
+) : BaseCartItem[] {
+	return [...goodsList].sort((a, b) => {
+		// 1. 按商品单价排序（优先级最高）
+		const priceA = a.skuData?.salePrice ?? a.salePrice;
+		const priceB = b.skuData?.salePrice ?? b.salePrice;
+		if (priceA !== priceB) {
+			return sortRule === "low_price_first" ? priceA - priceB : priceB - priceA;
+		}
 
-    // 2. 同价格按商品数量排序（降序，多的优先）
-    if (a.number !== b.number) {
-      return b.number - a.number;
-    }
+		// 2. 同价格按商品数量排序（降序，多的优先）
+		if (a.number !== b.number) {
+			return b.number - a.number;
+		}
 
-    // 3. 同价格同数量按加入购物车顺序（早的优先，用购物车ID匹配）
-    const orderA = cartOrder[String(a.id)] ?? Infinity;
-    const orderB = cartOrder[String(b.id)] ?? Infinity;
-    return orderA - orderB;
-  });
+		// 3. 同价格同数量按加入购物车顺序（早的优先，用购物车ID匹配）
+		const orderA = cartOrder[String(a.id)] ?? Infinity;
+		const orderB = cartOrder[String(b.id)] ?? Infinity;
+		return orderA - orderB;
+	});
 }
 
 /**
@@ -522,50 +505,50 @@ export function sortGoodsForCoupon(
  * @returns 满足优惠券门槛的金额基数
  */
 export function calcCouponThresholdAmount(
-  eligibleGoods: BaseCartItem[],
-  coupon: BaseCoupon,
-  config: Pick<OrderExtraConfig, "isMember" | "memberDiscountRate">,
-  activities: ActivityConfig[] = []
-): number {
-  let total = new BigNumber(0);
+	eligibleGoods : BaseCartItem[],
+	coupon : BaseCoupon,
+	config : Pick<OrderExtraConfig, "isMember" | "memberDiscountRate">,
+	activities : ActivityConfig[] = []
+) : number {
+	let total = new BigNumber(0);
 
-  for (const goods of eligibleGoods) {
-    const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
-    if (availableNum <= 0) continue;
+	for (const goods of eligibleGoods) {
+		const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
+		if (availableNum <= 0) continue;
 
-    // 1. 基础金额：默认用商品原价（SKU原价优先）
-    const basePrice = new BigNumber(
-      goods.skuData?.salePrice ?? goods.salePrice
-    );
-    let itemAmount = basePrice.multipliedBy(availableNum);
+		// 1. 基础金额：默认用商品原价（SKU原价优先）
+		const basePrice = new BigNumber(
+			goods.skuData?.salePrice ?? goods.salePrice
+		);
+		let itemAmount = basePrice.multipliedBy(availableNum);
 
-    // 2. 处理「与会员价/会员折扣同享」规则：若开启，用会员价计算
-    if (coupon.vipPriceShare) {
-      const memberPrice = new BigNumber(
-        calcMemberPrice(goods, config.isMember, config.memberDiscountRate)
-      );
-      itemAmount = memberPrice.multipliedBy(availableNum);
-    }
+		// 2. 处理「与会员价/会员折扣同享」规则：若开启，用会员价计算
+		if (coupon.vipPriceShare) {
+			const memberPrice = new BigNumber(
+				calcMemberPrice(goods, config.isMember, config.memberDiscountRate)
+			);
+			itemAmount = memberPrice.multipliedBy(availableNum);
+		}
 
-    // 3. 处理「与限时折扣同享」规则：若开启，叠加限时折扣（按商品ID匹配活动）
-    if (coupon.discountShare) {
-      const activity =
-        goods.activityInfo ??
-        activities.find(
-          (act) =>
-            act.type === ActivityType.TIME_LIMIT_DISCOUNT &&
-            (act.applicableProductIds || []).includes(String(goods.product_id)) // 核心修正：用商品ID匹配活动
-        );
+		// 3. 处理「与限时折扣同享」规则：若开启，叠加限时折扣（按商品ID匹配活动）
+		if (coupon.discountShare) {
+			const activity =
+				goods.activityInfo ??
+				activities.find(
+					(act) =>
+						act.type === ActivityType.TIME_LIMIT_DISCOUNT &&
+						(act.applicableProductIds || []).includes(String(goods.product_id)) // 核心修正：用商品ID匹配活动
+				);
 
-      if (activity) {
-        itemAmount = itemAmount.multipliedBy(activity.discountRate); // 叠加限时折扣
-      }
-    }
+			if (activity) {
+				itemAmount = itemAmount.multipliedBy(activity.discountRate); // 叠加限时折扣
+			}
+		}
 
-    total = total.plus(itemAmount);
-  }
+		total = total.plus(itemAmount);
+	}
 
-  return truncateToTwoDecimals(total.toNumber());
+	return truncateToTwoDecimals(total.toNumber());
 }
 
 // ============================ 3. 商品核心价格计算（核心修正：按商品ID匹配营销活动） ============================
@@ -576,99 +559,99 @@ export function calcCouponThresholdAmount(
  * @returns 单个商品实际单价（元）
  */
 export function calcSingleGoodsRealPrice(
-  goods: BaseCartItem,
-  config: Pick<
-    OrderExtraConfig,
-    "isMember" | "memberDiscountRate" | "limitTimeDiscount"
-  >
-): number {
-  const { isMember, memberDiscountRate, limitTimeDiscount: activity } = config;
+	goods : BaseCartItem,
+	config : Pick<
+		OrderExtraConfig,
+		"isMember" | "memberDiscountRate" | "limitTimeDiscount"
+	>
+) : number {
+	const { isMember, memberDiscountRate, limitTimeDiscount: activity } = config;
 
-  //如果是增菜价格为0
-  if (goods.is_gift||goods.isGift) {
-    return 0;
-  }
+	//如果是增菜价格为0
+	if (goods.is_gift || goods.isGift) {
+		return 0;
+	}
 
-  // 1. 优先级1：商家改价（改价后单价>0才生效）
-  if (goods.discountSaleAmount && goods.discountSaleAmount > 0) {
-    return truncateToTwoDecimals(goods.discountSaleAmount);
-  }
+	// 1. 优先级1：商家改价（改价后单价>0才生效）
+	if (goods.discountSaleAmount && goods.discountSaleAmount > 0) {
+		return truncateToTwoDecimals(goods.discountSaleAmount);
+	}
 
-  // 2. 优先级2：会员价（含会员折扣率，SKU会员价优先）
-  const memberPrice = new BigNumber(
-    calcMemberPrice(goods, isMember, memberDiscountRate)
-  );
-  
-  if(goods.is_time_discount||goods.isTimeDiscount){
-	  console.log('限时折扣',activity)
-	  console.log('goods',goods)
-    //限时折扣优先
-  const limitPrice=  truncateToTwoDecimals(
-     new BigNumber(goods.salePrice)
-       .times((activity?activity.discountRate:100)  / 100)
-       .decimalPlaces(2, BigNumber.ROUND_UP)
-       .toNumber()
-   );
-   console.log('limitPrice',limitPrice)
-   return limitPrice;
- }
-  // 3. 优先级3：营销活动折扣（如限时折扣，需按商品ID匹配活动）
-  let isActivityApplicable = false;
-  if (activity) {
-    if (activity.foodType == 1) {
-      isActivityApplicable = true;
-    } else {
-      const canUseGoods = activity.foods?.split(",") || [];
-      if (canUseGoods.find((v) => v == String(goods.product_id))) {
-        isActivityApplicable = true;
-      }
-    }
-  }
+	// 2. 优先级2：会员价（含会员折扣率，SKU会员价优先）
+	const memberPrice = new BigNumber(
+		calcMemberPrice(goods, isMember, memberDiscountRate)
+	);
 
-  if (!activity || !isActivityApplicable) {
-    return memberPrice.toNumber();
-  }
-  // //限时折扣优先或者会员价优先但是不是会员或者未开启会员价格时限时折扣优先
-  // if (
-  //   activity.discountPriority == "limit-time" ||
-  //   (activity.discountPriority == "vip-price" && !isMember) ||
-  //   (activity.discountPriority == "vip-price" && isMember && !goods.memberPrice)
-  // )
-  //  {
-  //   //限时折扣优先
-  //   return truncateToTwoDecimals(
-  //     new BigNumber(goods.salePrice)
-  //       .times(activity.discountRate / 100)
-  //       .decimalPlaces(2, BigNumber.ROUND_UP)
-  //       .toNumber()
-  //   );
-  // }
-  
-  if (activity.discountPriority == "vip-price" && isMember) {
-    return memberPrice.toNumber();
-  }
+	if (goods.is_time_discount || goods.isTimeDiscount) {
+		console.log('限时折扣', activity)
+		console.log('goods', goods)
+		//限时折扣优先
+		const limitPrice = truncateToTwoDecimals(
+			new BigNumber(goods.salePrice)
+				.times((activity ? activity.discountRate : 100) / 100)
+				.decimalPlaces(2, BigNumber.ROUND_UP)
+				.toNumber()
+		);
+		console.log('limitPrice', limitPrice)
+		return limitPrice;
+	}
+	// 3. 优先级3：营销活动折扣（如限时折扣，需按商品ID匹配活动）
+	let isActivityApplicable = false;
+	if (activity) {
+		if (activity.foodType == 1) {
+			isActivityApplicable = true;
+		} else {
+			const canUseGoods = activity.foods?.split(",") || [];
+			if (canUseGoods.find((v) => v == String(goods.product_id))) {
+				isActivityApplicable = true;
+			}
+		}
+	}
 
-  // 处理活动与会员的同享/不同享逻辑
-  if (activity.vipPriceShare) {
-    // 同享：会员价基础上叠加工活动折扣
-    return truncateToTwoDecimals(
-      memberPrice.multipliedBy(activity.discountRate).toNumber()
-    );
-  } else {
-    // 不同享：取会员价和活动价的最小值（活动价用SKU原价计算）
-    const basePriceForActivity = new BigNumber(
-      goods.skuData?.salePrice ?? goods.salePrice
-    );
-    const activityPrice = basePriceForActivity.multipliedBy(
-      activity.discountRate
-    );
+	if (!activity || !isActivityApplicable) {
+		return memberPrice.toNumber();
+	}
+	// //限时折扣优先或者会员价优先但是不是会员或者未开启会员价格时限时折扣优先
+	// if (
+	//   activity.discountPriority == "limit-time" ||
+	//   (activity.discountPriority == "vip-price" && !isMember) ||
+	//   (activity.discountPriority == "vip-price" && isMember && !goods.memberPrice)
+	// )
+	//  {
+	//   //限时折扣优先
+	//   return truncateToTwoDecimals(
+	//     new BigNumber(goods.salePrice)
+	//       .times(activity.discountRate / 100)
+	//       .decimalPlaces(2, BigNumber.ROUND_UP)
+	//       .toNumber()
+	//   );
+	// }
 
-    return truncateToTwoDecimals(
-      memberPrice.isLessThanOrEqualTo(activityPrice)
-        ? memberPrice.toNumber()
-        : activityPrice.toNumber()
-    );
-  }
+	if (activity.discountPriority == "vip-price" && isMember) {
+		return memberPrice.toNumber();
+	}
+
+	// 处理活动与会员的同享/不同享逻辑
+	if (activity.vipPriceShare) {
+		// 同享：会员价基础上叠加工活动折扣
+		return truncateToTwoDecimals(
+			memberPrice.multipliedBy(activity.discountRate).toNumber()
+		);
+	} else {
+		// 不同享：取会员价和活动价的最小值（活动价用SKU原价计算）
+		const basePriceForActivity = new BigNumber(
+			goods.skuData?.salePrice ?? goods.salePrice
+		);
+		const activityPrice = basePriceForActivity.multipliedBy(
+			activity.discountRate
+		);
+
+		return truncateToTwoDecimals(
+			memberPrice.isLessThanOrEqualTo(activityPrice)
+				? memberPrice.toNumber()
+				: activityPrice.toNumber()
+		);
+	}
 }
 
 /**
@@ -676,24 +659,24 @@ export function calcSingleGoodsRealPrice(
  * @param goodsList 商品列表
  * @returns 商品原价总和（元）
  */
-export function calcGoodsOriginalAmount(goodsList: BaseCartItem[]): number {
-  let total = new BigNumber(0);
+export function calcGoodsOriginalAmount(goodsList : BaseCartItem[]) : number {
+	let total = new BigNumber(0);
 
-  for (const goods of goodsList) {
-    const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
-    let basePrice = new BigNumber(0);
-    if (goods.is_temporary||goods.isTemporary) {
-      basePrice = new BigNumber(goods?.discountSaleAmount ?? 0);
-    } else if (goods.is_gift||goods.isGift) {
-      basePrice = new BigNumber(0);
-    } else {
-      basePrice = new BigNumber(goods.skuData?.salePrice ?? goods.salePrice); // SKU原价优先
-    }
+	for (const goods of goodsList) {
+		const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
+		let basePrice = new BigNumber(0);
+		if (goods.is_temporary || goods.isTemporary) {
+			basePrice = new BigNumber(goods?.discountSaleAmount ?? 0);
+		} else if (goods.is_gift || goods.isGift) {
+			basePrice = new BigNumber(0);
+		} else {
+			basePrice = new BigNumber(goods.skuData?.salePrice ?? goods.salePrice); // SKU原价优先
+		}
 
-    total = total.plus(basePrice.multipliedBy(availableNum));
-  }
+		total = total.plus(basePrice.multipliedBy(availableNum));
+	}
 
-  return truncateToTwoDecimals(total.toNumber());
+	return truncateToTwoDecimals(total.toNumber());
 }
 
 /**
@@ -704,24 +687,24 @@ export function calcGoodsOriginalAmount(goodsList: BaseCartItem[]): number {
  * @returns 商品实际总价（元）
  */
 export function calcGoodsRealAmount(
-  goodsList: BaseCartItem[],
-  config: Pick<
-    OrderExtraConfig,
-    "isMember" | "memberDiscountRate" | "limitTimeDiscount"
-  >
-): number {
-  let total = new BigNumber(0);
+	goodsList : BaseCartItem[],
+	config : Pick<
+		OrderExtraConfig,
+		"isMember" | "memberDiscountRate" | "limitTimeDiscount"
+	>
+) : number {
+	let total = new BigNumber(0);
 
-  for (const goods of goodsList) {
-    const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
-    if (availableNum <= 0) continue;
-    const realPrice = new BigNumber(calcSingleGoodsRealPrice(goods, config));
-	console.log('goods',goods);
-	console.log('realPrice',realPrice.toNumber());
-    total = total.plus(realPrice.multipliedBy(availableNum));
-  }
+	for (const goods of goodsList) {
+		const availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
+		if (availableNum <= 0) continue;
+		const realPrice = new BigNumber(calcSingleGoodsRealPrice(goods, config));
+		console.log('goods', goods);
+		console.log('realPrice', realPrice.toNumber());
+		total = total.plus(realPrice.multipliedBy(availableNum));
+	}
 
-  return truncateToTwoDecimals(total.toNumber());
+	return truncateToTwoDecimals(total.toNumber());
 }
 
 /**
@@ -731,14 +714,14 @@ export function calcGoodsRealAmount(
  * @returns 商品折扣总金额（元，≥0）
  */
 export function calcGoodsDiscountAmount(
-  goodsOriginalAmount: number,
-  goodsRealAmount: number
-): number {
-  const original = new BigNumber(goodsOriginalAmount);
-  const real = new BigNumber(goodsRealAmount);
-  const discount = original.minus(real);
+	goodsOriginalAmount : number,
+	goodsRealAmount : number
+) : number {
+	const original = new BigNumber(goodsOriginalAmount);
+	const real = new BigNumber(goodsRealAmount);
+	const discount = original.minus(real);
 
-  return truncateToTwoDecimals(Math.max(0, discount.toNumber()));
+	return truncateToTwoDecimals(Math.max(0, discount.toNumber()));
 }
 /**
  * 从满减活动的多门槛中，选择最优阈值（满金额最小且减免金额最大）
@@ -750,43 +733,43 @@ export function calcGoodsDiscountAmount(
  * @returns 最优阈值（无符合条件则返回undefined）
  */
 export function selectOptimalThreshold(
-  thresholds: FullReductionThreshold[] = [],
-  baseAmount: number,
-  goodsOriginalAmount: number,
-  goodsRealAmount: number,
-  discountShare: number = 0
-): FullReductionThreshold | undefined {
-  if (!thresholds.length) return undefined;
+	thresholds : FullReductionThreshold[] = [],
+	baseAmount : number,
+	goodsOriginalAmount : number,
+	goodsRealAmount : number,
+	discountShare : number = 0
+) : FullReductionThreshold | undefined {
+	if (!thresholds.length) return undefined;
 
-  // 第一步：确定满减门槛基数（根据discountShare规则）
-  const thresholdBase = baseAmount;
+	// 第一步：确定满减门槛基数（根据discountShare规则）
+	const thresholdBase = baseAmount;
 
-  // 第二步：筛选「满金额≤基数」且「减免金额>0」的有效阈值
-  const validThresholds = thresholds.filter((threshold) => {
-    const fullAmount = new BigNumber(threshold.fullAmount || 0);
-    const discountAmount = new BigNumber(threshold.discountAmount || 0);
+	// 第二步：筛选「满金额≤基数」且「减免金额>0」的有效阈值
+	const validThresholds = thresholds.filter((threshold) => {
+		const fullAmount = new BigNumber(threshold.fullAmount || 0);
+		const discountAmount = new BigNumber(threshold.discountAmount || 0);
 
-    return (
-      fullAmount.isLessThanOrEqualTo(thresholdBase) &&
-      discountAmount.isGreaterThan(0)
-    );
-  });
+		return (
+			fullAmount.isLessThanOrEqualTo(thresholdBase) &&
+			discountAmount.isGreaterThan(0)
+		);
+	});
 
-  if (!validThresholds.length) return undefined;
+	if (!validThresholds.length) return undefined;
 
-  // 找到抵扣金额最大的门槛项
-  const maxDiscountThreshold = validThresholds.reduce(
-    (maxItem, currentItem) => {
-      // 处理空值，默认抵扣金额为0
-      const maxDiscount = new BigNumber(maxItem?.discountAmount || 0);
-      const currentDiscount = new BigNumber(currentItem?.discountAmount || 0);
+	// 找到抵扣金额最大的门槛项
+	const maxDiscountThreshold = validThresholds.reduce(
+		(maxItem, currentItem) => {
+			// 处理空值，默认抵扣金额为0
+			const maxDiscount = new BigNumber(maxItem?.discountAmount || 0);
+			const currentDiscount = new BigNumber(currentItem?.discountAmount || 0);
 
-      // 比较当前项和已存最大项的抵扣金额，保留更大的
-      return currentDiscount.gt(maxDiscount) ? currentItem : maxItem;
-    },
-    validThresholds[0] || null
-  ); // 初始值为数组第一项（若数组为空则返回null）
-  return maxDiscountThreshold;
+			// 比较当前项和已存最大项的抵扣金额，保留更大的
+			return currentDiscount.gt(maxDiscount) ? currentItem : maxItem;
+		},
+		validThresholds[0] || null
+	); // 初始值为数组第一项（若数组为空则返回null）
+	return maxDiscountThreshold;
 }
 
 /**
@@ -797,25 +780,25 @@ export function selectOptimalThreshold(
  * @returns 实际减免金额（元，未达门槛则0）
  */
 export function calcFullReductionAmount(
-  baseAmount: number,
-  optimalActivity?: FullReductionActivity,
-  optimalThreshold?: FullReductionThreshold
-): number {
-  if (!optimalActivity || !optimalThreshold) return 0;
+	baseAmount : number,
+	optimalActivity ?: FullReductionActivity,
+	optimalThreshold ?: FullReductionThreshold
+) : number {
+	if (!optimalActivity || !optimalThreshold) return 0;
 
-  const baseAmountBn = new BigNumber(baseAmount);
-  const discountAmountBn = new BigNumber(optimalThreshold.discountAmount || 0);
+	const baseAmountBn = new BigNumber(baseAmount);
+	const discountAmountBn = new BigNumber(optimalThreshold.discountAmount || 0);
 
-  // 1. 基数必须为正（避免减免后为负）
-  if (baseAmountBn.isLessThanOrEqualTo(0)) return 0;
+	// 1. 基数必须为正（避免减免后为负）
+	if (baseAmountBn.isLessThanOrEqualTo(0)) return 0;
 
-  // 2. 减免金额不能超过基数（避免减成负数）
-  const maxReducible = baseAmountBn;
-  const actualReduction = discountAmountBn.isLessThanOrEqualTo(maxReducible)
-    ? discountAmountBn
-    : maxReducible;
+	// 2. 减免金额不能超过基数（避免减成负数）
+	const maxReducible = baseAmountBn;
+	const actualReduction = discountAmountBn.isLessThanOrEqualTo(maxReducible)
+		? discountAmountBn
+		: maxReducible;
 
-  return truncateToTwoDecimals(actualReduction.toNumber());
+	return truncateToTwoDecimals(actualReduction.toNumber());
 }
 
 // ------------------------------ 策略辅助函数 ------------------------------
@@ -823,13 +806,13 @@ export function calcFullReductionAmount(
  * 根据优惠券useShops列表判断门店是否匹配（适配BaseCoupon的useShops字段）
  */
 function isStoreMatchByList(
-  useShops: string[],
-  currentStoreId: string
-): boolean {
-  // 适用门店为空数组 → 无限制（所有门店适用）
-  if (useShops.length === 0) return true;
-  // 匹配当前门店ID（字符串比较，避免类型问题）
-  return useShops.includes(currentStoreId);
+	useShops : string[],
+	currentStoreId : string
+) : boolean {
+	// 适用门店为空数组 → 无限制（所有门店适用）
+	if (useShops.length === 0) return true;
+	// 匹配当前门店ID（字符串比较，避免类型问题）
+	return useShops.includes(currentStoreId);
 }
 
 /**
@@ -840,61 +823,61 @@ function isStoreMatchByList(
  * @returns 最优优惠券的抵扣结果（含商品券/满减券细分）
  */
 export function calcCouponDeduction(
-  backendCoupons: BackendCoupon[],
-  goodsList: BaseCartItem[],
-  config: Pick<
-    OrderExtraConfig,
-    "currentStoreId" | "isMember" | "memberDiscountRate"
-  > & {
-    activities: ActivityConfig[];
-    cartOrder: Record<string, number>;
-    dinnerType: "dine-in" | "take-out";
-    currentTime?: Date;
-  }
-): {
-  deductionAmount: number;
-  productCouponDeduction: number; // 新增：商品优惠券抵扣（兑换券/折扣券/买一送一等）
-  fullCouponDeduction: number; // 新增：满减优惠券抵扣
-  usedCoupon?: Coupon;
-  excludedProductIds: string[]; // 排除的商品ID列表（商品ID）
+	backendCoupons : BackendCoupon[],
+	goodsList : BaseCartItem[],
+	config : Pick<
+		OrderExtraConfig,
+		"currentStoreId" | "isMember" | "memberDiscountRate"
+	> & {
+		activities : ActivityConfig[];
+		cartOrder : Record<string, number>;
+		dinnerType : "dine-in" | "take-out";
+		currentTime ?: Date;
+	}
+) : {
+	deductionAmount : number;
+	productCouponDeduction : number; // 新增：商品优惠券抵扣（兑换券/折扣券/买一送一等）
+	fullCouponDeduction : number; // 新增：满减优惠券抵扣
+	usedCoupon ?: Coupon;
+	excludedProductIds : string[]; // 排除的商品ID列表（商品ID）
 } {
-  const goodsCoupon = backendCoupons.filter((v) => v.type == 2);
-  const discountCoupon = backendCoupons.filter((v) => v.type != 2);
+	const goodsCoupon = backendCoupons.filter((v) => v.type == 2);
+	const discountCoupon = backendCoupons.filter((v) => v.type != 2);
 
-  // 3. 计算非兑换券最优抵扣（传递已抵扣商品ID，避免重复，统计细分字段）
-  let nonExchangeResult: CouponResult = {
-    deductionAmount: discountCoupon.reduce((prve, cur): number => {
-      return prve + (cur.discountAmount || 0);
-    }, 0),
-    excludedProductIds: [],
-    usedCoupon: undefined,
-    productCouponDeduction: 0,
-    fullCouponDeduction: 0,
-  };
+	// 3. 计算非兑换券最优抵扣（传递已抵扣商品ID，避免重复，统计细分字段）
+	let nonExchangeResult : CouponResult = {
+		deductionAmount: discountCoupon.reduce((prve, cur) : number => {
+			return prve + (cur.discountAmount || 0);
+		}, 0),
+		excludedProductIds: [],
+		usedCoupon: undefined,
+		productCouponDeduction: 0,
+		fullCouponDeduction: 0,
+	};
 
-  // 4. 计算兑换券抵扣（排除非兑换券已抵扣的商品ID，统计商品券细分）
-  let exchangeResult: ExchangeCalculationResult = {
-    deductionAmount: goodsCoupon.reduce((prve, cur): number => {
-      return prve + (cur.discountAmount || 0);
-    }, 0),
-    excludedProductIds: [],
-    productCouponDeduction: 0,
-  };
+	// 4. 计算兑换券抵扣（排除非兑换券已抵扣的商品ID，统计商品券细分）
+	let exchangeResult : ExchangeCalculationResult = {
+		deductionAmount: goodsCoupon.reduce((prve, cur) : number => {
+			return prve + (cur.discountAmount || 0);
+		}, 0),
+		excludedProductIds: [],
+		productCouponDeduction: 0,
+	};
 
-  // 5. 汇总结果：兑换券与非兑换券不可同时使用，取抵扣金额大的
-  const exchangeBn = new BigNumber(exchangeResult.deductionAmount);
-  const nonExchangeBn = new BigNumber(nonExchangeResult.deductionAmount);
-  const isExchangeBetter = exchangeBn.isGreaterThan(nonExchangeBn);
+	// 5. 汇总结果：兑换券与非兑换券不可同时使用，取抵扣金额大的
+	const exchangeBn = new BigNumber(exchangeResult.deductionAmount);
+	const nonExchangeBn = new BigNumber(nonExchangeResult.deductionAmount);
+	const isExchangeBetter = exchangeBn.isGreaterThan(nonExchangeBn);
 
-  return {
-    deductionAmount: exchangeBn.plus(nonExchangeBn).toNumber(),
-    productCouponDeduction: exchangeResult.deductionAmount,
-    fullCouponDeduction: nonExchangeResult.deductionAmount, // 兑换券与满减券互斥，满减券抵扣置0
-    usedCoupon: isExchangeBetter ? undefined : nonExchangeResult.usedCoupon,
-    excludedProductIds: isExchangeBetter
-      ? exchangeResult.excludedProductIds
-      : nonExchangeResult.excludedProductIds,
-  };
+	return {
+		deductionAmount: exchangeBn.plus(nonExchangeBn).toNumber(),
+		productCouponDeduction: exchangeResult.deductionAmount,
+		fullCouponDeduction: nonExchangeResult.deductionAmount, // 兑换券与满减券互斥，满减券抵扣置0
+		usedCoupon: isExchangeBetter ? undefined : nonExchangeResult.usedCoupon,
+		excludedProductIds: isExchangeBetter
+			? exchangeResult.excludedProductIds
+			: nonExchangeResult.excludedProductIds,
+	};
 }
 
 // ============================ 5. 其他费用计算（无ID依赖，逻辑不变） ============================
@@ -905,31 +888,31 @@ export function calcCouponDeduction(
  * @returns 总打包费（元）
  */
 export function calcTotalPackFee(
-  goodsList: BaseCartItem[],
-  dinnerType: "dine-in" | "take-out"
-): number {
-  // if (dinnerType !== "take-out") return 0;
-  let total = new BigNumber(0);
+	goodsList : BaseCartItem[],
+	dinnerType : "dine-in" | "take-out"
+) : number {
+	// if (dinnerType !== "take-out") return 0;
+	let total = new BigNumber(0);
 
-  for (const goods of goodsList) {
-    const packNumber = goods.packNumber ? goods.packNumber * 1 : 0;
-    let availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
+	for (const goods of goodsList) {
+		const packNumber = goods.packNumber ? goods.packNumber * 1 : 0;
+		let availableNum = Math.max(0, goods.number - (goods.returnNum || 0));
 
-    if (availableNum === 0) continue;
+		if (availableNum === 0) continue;
 
-    // 计算单个商品打包数量（外卖全打包，堂食按配置，称重商品≤1）
-    let packNum = Math.min(availableNum, packNumber);
-    if (dinnerType === "take-out") {
-      packNum = availableNum;
-    }
-    if (goods.product_type === GoodsType.WEIGHT) {
-      packNum = Math.min(packNum, 1);
-    }
+		// 计算单个商品打包数量（外卖全打包，堂食按配置，称重商品≤1）
+		let packNum = Math.min(availableNum, packNumber);
+		if (dinnerType === "take-out") {
+			packNum = availableNum;
+		}
+		if (goods.product_type === GoodsType.WEIGHT) {
+			packNum = Math.min(packNum, 1);
+		}
 
-    total = total.plus(new BigNumber(goods.packFee || 0).multipliedBy(packNum));
-  }
+		total = total.plus(new BigNumber(goods.packFee || 0).multipliedBy(packNum));
+	}
 
-  return truncateToTwoDecimals(total.toNumber());
+	return truncateToTwoDecimals(total.toNumber());
 }
 
 /**
@@ -937,12 +920,12 @@ export function calcTotalPackFee(
  * @param config 餐位费配置
  * @returns 餐位费（元，未启用则0）
  */
-export function calcSeatFee(config: SeatFeeConfig): number {
-  if (!config.isEnabled || config.personCount == 0) return 0;
-  const personCount = Math.max(1, config.personCount); // 至少1人
-  return truncateToTwoDecimals(
-    new BigNumber(config.pricePerPerson).multipliedBy(personCount).toNumber()
-  );
+export function calcSeatFee(config : SeatFeeConfig) : number {
+	if (!config.isEnabled || config.personCount == 0) return 0;
+	const personCount = Math.max(1, config.personCount); // 至少1人
+	return truncateToTwoDecimals(
+		new BigNumber(config.pricePerPerson).multipliedBy(personCount).toNumber()
+	);
 }
 
 /**
@@ -953,56 +936,56 @@ export function calcSeatFee(config: SeatFeeConfig): number {
  * @returns 积分抵扣金额 + 实际使用积分
  */
 export function calcPointDeduction(
-  userPoints: number,
-  rule: PointDeductionRule,
-  maxDeductionLimit: number
-): {
-  deductionAmount: number;
-  usedPoints: number;
+	userPoints : number,
+	rule : PointDeductionRule,
+	maxDeductionLimit : number
+) : {
+	deductionAmount : number;
+	usedPoints : number;
 } {
-  if (rule.pointsPerYuan <= 0 || userPoints <= 0) {
-    return { deductionAmount: 0, usedPoints: 0 };
-  }
+	if (rule.pointsPerYuan <= 0 || userPoints <= 0) {
+		return { deductionAmount: 0, usedPoints: 0 };
+	}
 
-  const userPointsBn = new BigNumber(userPoints);
-  const pointsPerYuanBn = new BigNumber(rule.pointsPerYuan);
-  const maxLimitBn = new BigNumber(maxDeductionLimit);
+	const userPointsBn = new BigNumber(userPoints);
+	const pointsPerYuanBn = new BigNumber(rule.pointsPerYuan);
+	const maxLimitBn = new BigNumber(maxDeductionLimit);
 
-  // 最大可抵扣金额（积分可抵金额 vs 规则最大 vs 订单上限）
-  const maxDeductByPoints = userPointsBn.dividedBy(pointsPerYuanBn);
-  const maxDeductAmount = maxDeductByPoints.isLessThan(
-    rule.maxDeductionAmount ?? Infinity
-  )
-    ? maxDeductByPoints
-    : new BigNumber(rule.maxDeductionAmount || Infinity).isLessThan(maxLimitBn)
-    ? maxDeductByPoints
-    : maxLimitBn;
+	// 最大可抵扣金额（积分可抵金额 vs 规则最大 vs 订单上限）
+	const maxDeductByPoints = userPointsBn.dividedBy(pointsPerYuanBn);
+	const maxDeductAmount = maxDeductByPoints.isLessThan(
+		rule.maxDeductionAmount ?? Infinity
+	)
+		? maxDeductByPoints
+		: new BigNumber(rule.maxDeductionAmount || Infinity).isLessThan(maxLimitBn)
+			? maxDeductByPoints
+			: maxLimitBn;
 
-  // 实际使用积分 = 抵扣金额 * 积分兑换比例
-  const usedPoints = maxDeductAmount.multipliedBy(pointsPerYuanBn);
+	// 实际使用积分 = 抵扣金额 * 积分兑换比例
+	const usedPoints = maxDeductAmount.multipliedBy(pointsPerYuanBn);
 
-  return {
-    deductionAmount: truncateToTwoDecimals(maxDeductAmount.toNumber()),
-    usedPoints: truncateToTwoDecimals(
-      Math.min(usedPoints.toNumber(), userPoints)
-    ), // 避免积分超扣
-  };
+	return {
+		deductionAmount: truncateToTwoDecimals(maxDeductAmount.toNumber()),
+		usedPoints: truncateToTwoDecimals(
+			Math.min(usedPoints.toNumber(), userPoints)
+		), // 避免积分超扣
+	};
 }
 
 function calcVipDiscountAmount(
-  goodsRealAmount: number,
-  shopUserInfo: ShopUserInfo
-): number {
-  if (!shopUserInfo.isVip || shopUserInfo.discount === 0) return 0;
-  if (shopUserInfo.isVip == 1 && shopUserInfo.isMemberPrice != 1) {
-    return 0;
-  }
-  return truncateToTwoDecimals(
-    new BigNumber(goodsRealAmount)
-      .times((100 - (shopUserInfo.discount || 100)) / 100)
-      .decimalPlaces(2, BigNumber.ROUND_DOWN)
-      .toNumber()
-  );
+	goodsRealAmount : number,
+	shopUserInfo : ShopUserInfo
+) : number {
+	if (!shopUserInfo.isVip || shopUserInfo.discount === 0) return 0;
+	if (shopUserInfo.isVip == 1 && shopUserInfo.isMemberPrice != 1) {
+		return 0;
+	}
+	return truncateToTwoDecimals(
+		new BigNumber(goodsRealAmount)
+			.times((100 - (shopUserInfo.discount || 100)) / 100)
+			.decimalPlaces(2, BigNumber.ROUND_DOWN)
+			.toNumber()
+	);
 }
 
 // ============================ 6. 订单总费用汇总与实付金额计算（核心入口，补充细分字段） ============================
@@ -1018,372 +1001,372 @@ function calcVipDiscountAmount(
  * @returns 订单费用汇总（含所有子项和实付金额，新增商品券/满减券细分）
  */
 export function calculateOrderCostSummary(
-  goodsList: BaseCartItem[],
-  dinnerType: "dine-in" | "take-out", // 前端就餐类型
-  backendCoupons: BackendCoupon[] = [],
-  activities: ActivityConfig[] = [],
-  config: OrderExtraConfig, // 含后端满减活动、currentDinnerType
-  cartOrder: Record<string, number> = {},
-  currentTime: Date = new Date()
-): OrderCostSummary {
-  //是否使用霸王餐，霸王餐配置
-  const {
-    isFreeDine,
-    freeDineConfig,
-    limitTimeDiscount,
-    fullReductionActivities,
-    shopUserInfo,
-  } = config;
+	goodsList : BaseCartItem[],
+	dinnerType : "dine-in" | "take-out", // 前端就餐类型
+	backendCoupons : BackendCoupon[] = [],
+	activities : ActivityConfig[] = [],
+	config : OrderExtraConfig, // 含后端满减活动、currentDinnerType
+	cartOrder : Record<string, number> = {},
+	currentTime : Date = new Date()
+) : OrderCostSummary {
+	//是否使用霸王餐，霸王餐配置
+	const {
+		isFreeDine,
+		freeDineConfig,
+		limitTimeDiscount,
+		fullReductionActivities,
+		shopUserInfo,
+	} = config;
 
-  // ------------------------------ 1. 基础费用计算 ------------------------------
-  const goodsOriginalAmount = calcGoodsOriginalAmount(goodsList); // 商品原价总和
-  const goodsRealAmount = calcGoodsRealAmount(
-    // 商品折扣后总和
-    goodsList,
-    {
-      isMember: config.isMember,
-      memberDiscountRate: config.memberDiscountRate,
-      limitTimeDiscount: config.limitTimeDiscount,
-    }
-  );
-  const goodsDiscountAmount = calcGoodsDiscountAmount(
-    goodsOriginalAmount,
-    goodsRealAmount
-  ); // 商品折扣金额
+	// ------------------------------ 1. 基础费用计算 ------------------------------
+	const goodsOriginalAmount = calcGoodsOriginalAmount(goodsList); // 商品原价总和
+	const goodsRealAmount = calcGoodsRealAmount(
+		// 商品折扣后总和
+		goodsList,
+		{
+			isMember: config.isMember,
+			memberDiscountRate: config.memberDiscountRate,
+			limitTimeDiscount: config.limitTimeDiscount,
+		}
+	);
+	const goodsDiscountAmount = calcGoodsDiscountAmount(
+		goodsOriginalAmount,
+		goodsRealAmount
+	); // 商品折扣金额
 
-  const newUserDiscount = config.newUserDiscount || 0; // 新客立减
+	const newUserDiscount = config.newUserDiscount || 0; // 新客立减
 
-  //  其他费用计算（原有逻辑不变） ------------------------------
-  const packFee = calcTotalPackFee(goodsList, dinnerType); // 打包费
-  let seatFee = calcSeatFee(config.seatFeeConfig); // 餐位费
-  seatFee = dinnerType === "dine-in" ? seatFee : 0; // 外卖不收餐位费
-  const additionalFee = Math.max(0, config.additionalFee); // 附加费
+	//  其他费用计算（原有逻辑不变） ------------------------------
+	const packFee = calcTotalPackFee(goodsList, dinnerType); // 打包费
+	let seatFee = calcSeatFee(config.seatFeeConfig); // 餐位费
+	seatFee = dinnerType === "dine-in" ? seatFee : 0; // 外卖不收餐位费
+	const additionalFee = Math.max(0, config.additionalFee); // 附加费
 
-  // ------------------------------ 2. 满减活动计算（核心步骤） ------------------------------
-  let usedFullReductionActivity: FullReductionActivity | undefined;
-  let usedFullReductionThreshold: FullReductionThreshold | undefined;
-  let fullReductionAmount = 0;
-  let usedFullReductionActivityFullAmount = calcFullReductionActivityFullAmount(
-    goodsList,
-    usedFullReductionActivity,
-    config.limitTimeDiscount,
-    config.isMember,
-    seatFee,
-    packFee
-  );
+	// ------------------------------ 2. 满减活动计算（核心步骤） ------------------------------
+	let usedFullReductionActivity : FullReductionActivity | undefined;
+	let usedFullReductionThreshold : FullReductionThreshold | undefined;
+	let fullReductionAmount = 0;
+	let usedFullReductionActivityFullAmount = calcFullReductionActivityFullAmount(
+		goodsList,
+		usedFullReductionActivity,
+		config.limitTimeDiscount,
+		config.isMember,
+		seatFee,
+		packFee
+	);
 
-  // 2.1 筛选最优满减活动（后端活动列表、当前店铺、就餐类型、时间）
-  usedFullReductionActivity = filterOptimalFullReductionActivity(
-    config.fullReductionActivities,
-    Number(config.currentStoreId), // 转换为数字（后端shopId是number）
-    config.currentDinnerType, // 后端useType匹配的就餐类型（如"dine"）
-    currentTime
-  );
+	// 2.1 筛选最优满减活动（后端活动列表、当前店铺、就餐类型、时间）
+	usedFullReductionActivity = filterOptimalFullReductionActivity(
+		config.fullReductionActivities,
+		Number(config.currentStoreId), // 转换为数字（后端shopId是number）
+		config.currentDinnerType, // 后端useType匹配的就餐类型（如"dine"）
+		currentTime
+	);
 
-  // 2.2 计算满减基数（先扣新客立减）
-  let baseAfterNewUserDiscount = new BigNumber(
-    limitTimeDiscount &&
-    limitTimeDiscount.id &&
-    usedFullReductionActivity &&
-    !usedFullReductionActivity.discountShare
-      ? goodsRealAmount
-      : goodsRealAmount
-  )
-    .minus(newUserDiscount)
-    .plus(packFee)
-    .plus(seatFee)
-    .plus(additionalFee)
-    .toNumber();
-  baseAfterNewUserDiscount =
-    baseAfterNewUserDiscount > 0 ? baseAfterNewUserDiscount : 0;
+	// 2.2 计算满减基数（先扣新客立减）
+	let baseAfterNewUserDiscount = new BigNumber(
+		limitTimeDiscount &&
+			limitTimeDiscount.id &&
+			usedFullReductionActivity &&
+			!usedFullReductionActivity.discountShare
+			? goodsRealAmount
+			: goodsRealAmount
+	)
+		.minus(newUserDiscount)
+		.plus(packFee)
+		.plus(seatFee)
+		.plus(additionalFee)
+		.toNumber();
+	baseAfterNewUserDiscount =
+		baseAfterNewUserDiscount > 0 ? baseAfterNewUserDiscount : 0;
 
-  // 2.3 选择最优满减阈值（多门槛场景）
-  if (usedFullReductionActivity) {
-    //计算当前满减活动的门槛金额
-    usedFullReductionActivityFullAmount = calcFullReductionActivityFullAmount(
-      goodsList,
-      usedFullReductionActivity,
-      config.limitTimeDiscount,
-      config.isMember,
-      seatFee,
-      packFee
-    );
-    usedFullReductionThreshold = selectOptimalThreshold(
-      usedFullReductionActivity.thresholds,
-      usedFullReductionActivityFullAmount,
-      goodsOriginalAmount,
-      goodsRealAmount,
-      usedFullReductionActivity.discountShare || 0 // 与限时折扣同享规则
-    );
-    // 2.4 计算满减实际减免金额
-    fullReductionAmount = calcFullReductionAmount(
-      baseAfterNewUserDiscount,
-      usedFullReductionActivity,
-      usedFullReductionThreshold
-    );
-  }
+	// 2.3 选择最优满减阈值（多门槛场景）
+	if (usedFullReductionActivity) {
+		//计算当前满减活动的门槛金额
+		usedFullReductionActivityFullAmount = calcFullReductionActivityFullAmount(
+			goodsList,
+			usedFullReductionActivity,
+			config.limitTimeDiscount,
+			config.isMember,
+			seatFee,
+			packFee
+		);
+		usedFullReductionThreshold = selectOptimalThreshold(
+			usedFullReductionActivity.thresholds,
+			usedFullReductionActivityFullAmount,
+			goodsOriginalAmount,
+			goodsRealAmount,
+			usedFullReductionActivity.discountShare || 0 // 与限时折扣同享规则
+		);
+		// 2.4 计算满减实际减免金额
+		fullReductionAmount = calcFullReductionAmount(
+			baseAfterNewUserDiscount,
+			usedFullReductionActivity,
+			usedFullReductionThreshold
+		);
+	}
 
-  // ------------------------------ 3. 优惠券抵扣（适配满减同享规则） ------------------------------
-  let couponDeductionAmount = 0;
-  let productCouponDeduction = 0;
-  let fullCouponDeduction = 0;
-  let usedCoupon: Coupon | undefined;
-  let excludedProductIds: string[] = [];
+	// ------------------------------ 3. 优惠券抵扣（适配满减同享规则） ------------------------------
+	let couponDeductionAmount = 0;
+	let productCouponDeduction = 0;
+	let fullCouponDeduction = 0;
+	let usedCoupon : Coupon | undefined;
+	let excludedProductIds : string[] = [];
 
-  const couponResult = calcCouponDeduction(
-    // 原有优惠券计算函数
-    backendCoupons,
-    goodsList,
-    {
-      currentStoreId: config.currentStoreId,
-      isMember: config.isMember,
-      memberDiscountRate: config.memberDiscountRate,
-      activities,
-      cartOrder,
-      dinnerType,
-      currentTime,
-    }
-  );
-  couponDeductionAmount = couponResult.deductionAmount;
-  productCouponDeduction = couponResult.productCouponDeduction;
-  fullCouponDeduction = couponResult.fullCouponDeduction;
-  usedCoupon = couponResult.usedCoupon;
-  excludedProductIds = couponResult.excludedProductIds;
+	const couponResult = calcCouponDeduction(
+		// 原有优惠券计算函数
+		backendCoupons,
+		goodsList,
+		{
+			currentStoreId: config.currentStoreId,
+			isMember: config.isMember,
+			memberDiscountRate: config.memberDiscountRate,
+			activities,
+			cartOrder,
+			dinnerType,
+			currentTime,
+		}
+	);
+	couponDeductionAmount = couponResult.deductionAmount;
+	productCouponDeduction = couponResult.productCouponDeduction;
+	fullCouponDeduction = couponResult.fullCouponDeduction;
+	usedCoupon = couponResult.usedCoupon;
+	excludedProductIds = couponResult.excludedProductIds;
 
-  // 若满减与优惠券同享（couponShare=1），才计算优惠券；否则优惠券抵扣为0
-  if (
-    usedFullReductionThreshold &&
-    (!usedFullReductionActivity || !usedFullReductionActivity.couponShare)
-  ) {
-    couponDeductionAmount = 0;
-    productCouponDeduction = 0;
-    fullCouponDeduction = 0;
-    usedCoupon = undefined;
-    excludedProductIds = [];
-  }
+	// 若满减与优惠券同享（couponShare=1），才计算优惠券；否则优惠券抵扣为0
+	if (
+		usedFullReductionThreshold &&
+		(!usedFullReductionActivity || !usedFullReductionActivity.couponShare)
+	) {
+		couponDeductionAmount = 0;
+		productCouponDeduction = 0;
+		fullCouponDeduction = 0;
+		usedCoupon = undefined;
+		excludedProductIds = [];
+	}
 
-  // ------------------------------ 4. 积分抵扣（适配满减同享规则） ------------------------------
-  let pointDeductionAmount = 0;
-  let usedPoints = 0;
+	// ------------------------------ 4. 积分抵扣（适配满减同享规则） ------------------------------
+	let pointDeductionAmount = 0;
+	let usedPoints = 0;
 
-  // 计算积分抵扣基数（商品折扣后 - 新客立减 - 满减 - 优惠券 + 餐位费 + 打包费 + 附加费）
-  let maxPointDeductionLimit = new BigNumber(goodsRealAmount)
-    .minus(newUserDiscount)
-    .minus(fullReductionAmount)
-    .minus(couponDeductionAmount)
-    .plus(seatFee)
-    .plus(packFee)
-    .plus(additionalFee)
-    .toNumber();
-  maxPointDeductionLimit =
-    maxPointDeductionLimit > 0 ? maxPointDeductionLimit : 0;
+	// 计算积分抵扣基数（商品折扣后 - 新客立减 - 满减 - 优惠券 + 餐位费 + 打包费 + 附加费）
+	let maxPointDeductionLimit = new BigNumber(goodsRealAmount)
+		.minus(newUserDiscount)
+		.minus(fullReductionAmount)
+		.minus(couponDeductionAmount)
+		.plus(seatFee)
+		.plus(packFee)
+		.plus(additionalFee)
+		.toNumber();
+	maxPointDeductionLimit =
+		maxPointDeductionLimit > 0 ? maxPointDeductionLimit : 0;
 
-  const pointResult = calcPointDeduction(
-    config.userPoints,
-    config.pointDeductionRule,
-    maxPointDeductionLimit
-  );
+	const pointResult = calcPointDeduction(
+		config.userPoints,
+		config.pointDeductionRule,
+		maxPointDeductionLimit
+	);
 
-  pointDeductionAmount = pointResult.deductionAmount;
-  usedPoints = pointResult.usedPoints;
-  // 若满减与积分不同享（pointsShare=1）积分抵扣为0
-  if (
-    usedFullReductionThreshold &&
-    (!usedFullReductionActivity || !usedFullReductionActivity.pointsShare)
-  ) {
-    pointDeductionAmount = 0;
-    usedPoints = 0;
-  }
+	pointDeductionAmount = pointResult.deductionAmount;
+	usedPoints = pointResult.usedPoints;
+	// 若满减与积分不同享（pointsShare=1）积分抵扣为0
+	if (
+		usedFullReductionThreshold &&
+		(!usedFullReductionActivity || !usedFullReductionActivity.pointsShare)
+	) {
+		pointDeductionAmount = 0;
+		usedPoints = 0;
+	}
 
-  //使用霸王餐
-  if (isFreeDine && freeDineConfig && freeDineConfig.enable) {
-    fullReductionAmount = 0;
-    //不与优惠券同享
-    if (!freeDineConfig.withCoupon) {
-      couponDeductionAmount = 0;
-      productCouponDeduction = 0;
-      fullCouponDeduction = 0;
-      usedCoupon = undefined;
-      excludedProductIds = [];
-    }
-    //不与积分同享
-    if (!freeDineConfig.withPoints) {
-      pointDeductionAmount = 0;
-      usedPoints = 0;
-    }
-  }
+	//使用霸王餐
+	if (isFreeDine && freeDineConfig && freeDineConfig.enable) {
+		fullReductionAmount = 0;
+		//不与优惠券同享
+		if (!freeDineConfig.withCoupon) {
+			couponDeductionAmount = 0;
+			productCouponDeduction = 0;
+			fullCouponDeduction = 0;
+			usedCoupon = undefined;
+			excludedProductIds = [];
+		}
+		//不与积分同享
+		if (!freeDineConfig.withPoints) {
+			pointDeductionAmount = 0;
+			usedPoints = 0;
+		}
+	}
 
-  // 商家减免计算（原有逻辑不变）
-  const merchantReductionConfig = config.merchantReduction;
-  let merchantReductionActualAmount = 0;
-  const maxMerchantReductionLimit = new BigNumber(goodsRealAmount)
-    .minus(newUserDiscount)
-    .minus(fullReductionAmount)
-    .minus(couponDeductionAmount)
-    .minus(pointDeductionAmount)
-    .plus(seatFee)
-    .plus(packFee)
-    .isGreaterThan(0)
-    ? new BigNumber(goodsRealAmount)
-        .minus(newUserDiscount)
-        .minus(fullReductionAmount)
-        .minus(couponDeductionAmount)
-        .minus(pointDeductionAmount)
-        .plus(seatFee)
-        .plus(packFee)
-        .toNumber()
-    : 0;
+	// 商家减免计算（原有逻辑不变）
+	const merchantReductionConfig = config.merchantReduction;
+	let merchantReductionActualAmount = 0;
+	const maxMerchantReductionLimit = new BigNumber(goodsRealAmount)
+		.minus(newUserDiscount)
+		.minus(fullReductionAmount)
+		.minus(couponDeductionAmount)
+		.minus(pointDeductionAmount)
+		.plus(seatFee)
+		.plus(packFee)
+		.isGreaterThan(0)
+		? new BigNumber(goodsRealAmount)
+			.minus(newUserDiscount)
+			.minus(fullReductionAmount)
+			.minus(couponDeductionAmount)
+			.minus(pointDeductionAmount)
+			.plus(seatFee)
+			.plus(packFee)
+			.toNumber()
+		: 0;
 
-  switch (merchantReductionConfig.type) {
-    case MerchantReductionType.FIXED_AMOUNT:
-      merchantReductionActualAmount = Math.min(
-        merchantReductionConfig.fixedAmount || 0,
-        maxMerchantReductionLimit
-      );
-      break;
-    case MerchantReductionType.DISCOUNT_RATE:
-      const validRate =
-        Math.max(0, Math.min(100, merchantReductionConfig.discountRate || 0)) /
-        100;
-      merchantReductionActualAmount =
-        maxMerchantReductionLimit * (1 - validRate);
-      break;
-  }
-  merchantReductionActualAmount = Math.max(
-    0,
-    truncateToTwoDecimals(merchantReductionActualAmount)
-  );
+	switch (merchantReductionConfig.type) {
+		case MerchantReductionType.FIXED_AMOUNT:
+			merchantReductionActualAmount = Math.min(
+				merchantReductionConfig.fixedAmount || 0,
+				maxMerchantReductionLimit
+			);
+			break;
+		case MerchantReductionType.DISCOUNT_RATE:
+			const validRate =
+				Math.max(0, Math.min(100, merchantReductionConfig.discountRate || 0)) /
+				100;
+			merchantReductionActualAmount =
+				maxMerchantReductionLimit * (1 - validRate);
+			break;
+	}
+	merchantReductionActualAmount = Math.max(
+		0,
+		truncateToTwoDecimals(merchantReductionActualAmount)
+	);
 
-  // 会员折扣减免
-  const vipDiscountAmount = calcVipDiscountAmount(
-    new BigNumber(goodsRealAmount)
-      .minus(couponDeductionAmount)
-      .plus(packFee)
-      .plus(seatFee)
-      .minus(newUserDiscount)
-      .minus(fullReductionAmount)
-      .toNumber(),
-    shopUserInfo
-  );
-  // ------------------------------ 6. 最终实付金额计算 ------------------------------
-  const finalPayAmountBn = new BigNumber(goodsRealAmount)
-    .minus(newUserDiscount)
-    .minus(vipDiscountAmount)
-    .minus(fullReductionAmount)
-    .minus(couponDeductionAmount)
-    .minus(pointDeductionAmount)
-    .minus(merchantReductionActualAmount)
-    .plus(seatFee)
-    .plus(packFee)
-    .plus(additionalFee);
-  let finalPayAmount = Math.max(
-    0,
-    truncateToTwoDecimals(finalPayAmountBn.toNumber())
-  );
-  // ------------------------------ 使用霸王餐计算 ------------------------------
-  let orderOriginFinalPayAmount = finalPayAmount;
-  if (isFreeDine && freeDineConfig && freeDineConfig.enable) {
-    finalPayAmount = BigNumber(finalPayAmount)
-      .times(freeDineConfig.rechargeTimes)
-      .toNumber();
-  }
+	// 会员折扣减免
+	const vipDiscountAmount = calcVipDiscountAmount(
+		new BigNumber(goodsRealAmount)
+			.minus(couponDeductionAmount)
+			.plus(packFee)
+			.plus(seatFee)
+			.minus(newUserDiscount)
+			.minus(fullReductionAmount)
+			.toNumber(),
+		shopUserInfo
+	);
+	// ------------------------------ 6. 最终实付金额计算 ------------------------------
+	const finalPayAmountBn = new BigNumber(goodsRealAmount)
+		.minus(newUserDiscount)
+		.minus(vipDiscountAmount)
+		.minus(fullReductionAmount)
+		.minus(couponDeductionAmount)
+		.minus(pointDeductionAmount)
+		.minus(merchantReductionActualAmount)
+		.plus(seatFee)
+		.plus(packFee)
+		.plus(additionalFee);
+	let finalPayAmount = Math.max(
+		0,
+		truncateToTwoDecimals(finalPayAmountBn.toNumber())
+	);
+	// ------------------------------ 使用霸王餐计算 ------------------------------
+	let orderOriginFinalPayAmount = finalPayAmount;
+	if (isFreeDine && freeDineConfig && freeDineConfig.enable) {
+		finalPayAmount = BigNumber(finalPayAmount)
+			.times(freeDineConfig.rechargeTimes)
+			.toNumber();
+	}
 
-  // ------------------------------ 7. 总优惠金额计算 ------------------------------
-  const totalDiscountAmount = truncateToTwoDecimals(
-    new BigNumber(goodsDiscountAmount)
-      .plus(newUserDiscount)
-      .plus(fullReductionAmount)
-      .plus(couponDeductionAmount)
-      .plus(pointDeductionAmount)
-      .plus(merchantReductionActualAmount)
-      .plus(vipDiscountAmount)
-      .toNumber()
-  );
-  //积分可抵扣最大金额 最终支付金额+积分抵扣-商家减免
-  const scoreMaxMoney = new BigNumber(finalPayAmount)
-    .plus(pointDeductionAmount)
-    .minus(merchantReductionActualAmount)
-    .toNumber();
+	// ------------------------------ 7. 总优惠金额计算 ------------------------------
+	const totalDiscountAmount = truncateToTwoDecimals(
+		new BigNumber(goodsDiscountAmount)
+			.plus(newUserDiscount)
+			.plus(fullReductionAmount)
+			.plus(couponDeductionAmount)
+			.plus(pointDeductionAmount)
+			.plus(merchantReductionActualAmount)
+			.plus(vipDiscountAmount)
+			.toNumber()
+	);
+	//积分可抵扣最大金额 最终支付金额+积分抵扣-商家减免
+	const scoreMaxMoney = new BigNumber(finalPayAmount)
+		.plus(pointDeductionAmount)
+		.minus(merchantReductionActualAmount)
+		.toNumber();
 
-  // ------------------------------ 8. 返回完整结果 ------------------------------
-  return {
-    goodsList: goodsList,
-    goodsTotal: goodsList.reduce(
-      (sum, g) => sum + Math.max(0, g.number - (g.returnNum || 0)),
-      0
-    ),
-    goodsRealAmount,
-    goodsOriginalAmount,
-    goodsDiscountAmount,
-    couponDeductionAmount,
-    productCouponDeduction,
-    fullCouponDeduction,
-    pointDeductionAmount,
-    seatFee,
-    packFee,
-    totalDiscountAmount,
-    //最终支付原金额
-    orderOriginFinalPayAmount,
-    //积分最大可抵扣金额
-    scoreMaxMoney,
-    // 满减活动明细（后端字段）
-    fullReduction: {
-      usedFullReductionActivityFullAmount: usedFullReductionActivityFullAmount,
-      usedActivity: usedFullReductionActivity,
-      usedThreshold: usedFullReductionThreshold,
-      actualAmount: truncateToTwoDecimals(fullReductionAmount),
-    },
-    vipDiscountAmount: vipDiscountAmount, //会员折扣减免金额
-    merchantReduction: {
-      type: merchantReductionConfig.type,
-      originalConfig: merchantReductionConfig,
-      actualAmount: merchantReductionActualAmount,
-    },
-    additionalFee,
-    finalPayAmount,
-    couponUsed: usedCoupon,
-    pointUsed: usedPoints,
-    newUserDiscount,
-    dinnerType,
-    config,
-  };
+	// ------------------------------ 8. 返回完整结果 ------------------------------
+	return {
+		goodsList: goodsList,
+		goodsTotal: goodsList.reduce(
+			(sum, g) => sum + Math.max(0, g.number - (g.returnNum || 0)),
+			0
+		),
+		goodsRealAmount,
+		goodsOriginalAmount,
+		goodsDiscountAmount,
+		couponDeductionAmount,
+		productCouponDeduction,
+		fullCouponDeduction,
+		pointDeductionAmount,
+		seatFee,
+		packFee,
+		totalDiscountAmount,
+		//最终支付原金额
+		orderOriginFinalPayAmount,
+		//积分最大可抵扣金额
+		scoreMaxMoney,
+		// 满减活动明细（后端字段）
+		fullReduction: {
+			usedFullReductionActivityFullAmount: usedFullReductionActivityFullAmount,
+			usedActivity: usedFullReductionActivity,
+			usedThreshold: usedFullReductionThreshold,
+			actualAmount: truncateToTwoDecimals(fullReductionAmount),
+		},
+		vipDiscountAmount: vipDiscountAmount, //会员折扣减免金额
+		merchantReduction: {
+			type: merchantReductionConfig.type,
+			originalConfig: merchantReductionConfig,
+			actualAmount: merchantReductionActualAmount,
+		},
+		additionalFee,
+		finalPayAmount,
+		couponUsed: usedCoupon,
+		pointUsed: usedPoints,
+		newUserDiscount,
+		dinnerType,
+		config,
+	};
 }
 
-export function isWeightGoods(goods: BaseCartItem): boolean {
-  return goods.product_type === GoodsType.WEIGHT;
+export function isWeightGoods(goods : BaseCartItem) : boolean {
+	return goods.product_type === GoodsType.WEIGHT;
 }
 
 // ============================ 7. 对外暴露工具库 ============================
 export const OrderPriceCalculator = {
-  // 基础工具
-  truncateToTwoDecimals,
-  isTemporaryGoods,
-  isGiftGoods,
-  formatDiscountRate,
-  filterThresholdGoods,
-  isWeightGoods,
-  // 商品价格计算
-  calcSingleGoodsRealPrice,
-  calcGoodsOriginalAmount,
-  calcGoodsRealAmount,
-  calcGoodsDiscountAmount,
-  //满减活动工具
-  filterOptimalFullReductionActivity,
-  // 优惠券计算
-  calcCouponDeduction,
-  // 其他费用计算
-  calcTotalPackFee,
-  calcSeatFee,
-  calcPointDeduction,
-  // 核心入口
-  calculateOrderCostSummary,
-  // 枚举导出
-  Enums: {
-    GoodsType,
-    CouponType,
-    ActivityType,
-    WEEKDAY_MAP,
-  },
+	// 基础工具
+	truncateToTwoDecimals,
+	isTemporaryGoods,
+	isGiftGoods,
+	formatDiscountRate,
+	filterThresholdGoods,
+	isWeightGoods,
+	// 商品价格计算
+	calcSingleGoodsRealPrice,
+	calcGoodsOriginalAmount,
+	calcGoodsRealAmount,
+	calcGoodsDiscountAmount,
+	//满减活动工具
+	filterOptimalFullReductionActivity,
+	// 优惠券计算
+	calcCouponDeduction,
+	// 其他费用计算
+	calcTotalPackFee,
+	calcSeatFee,
+	calcPointDeduction,
+	// 核心入口
+	calculateOrderCostSummary,
+	// 枚举导出
+	Enums: {
+		GoodsType,
+		CouponType,
+		ActivityType,
+		WEEKDAY_MAP,
+	},
 };
 
-export default OrderPriceCalculator;
+export default OrderPriceCalculator;
\ No newline at end of file
diff --git a/pages/product/index.vue b/pages/product/index.vue
index ac3586d..be6ca7f 100644
--- a/pages/product/index.vue
+++ b/pages/product/index.vue
@@ -49,14 +49,13 @@
 					<view class="panelfive_list">
 						<view class="panelfiveitem" @click="clickspecifications(item, index, index, '热销')"
 							v-for="(item, index) in shopProductList.hots" :key="index">
-							
+
 
 							<view class="relative">
 								<image @click.stop="getImgs(item)" class="panelfiveitemimage" :src="item.coverImg"
 									mode="aspectFill"></image>
-									<view class="limitDiscount" v-if="showLimitDiscount(item)"
-									  >限时折扣{{ limitDiscountCountdown }}</view
-									>
+								<view class="limitDiscount" v-if="showLimitDiscount(item)">
+									限时折扣{{ limitDiscountCountdown }}</view>
 								<!-- <view class="limitDiscount" v-if="item.is_time_discount">
 									限时折扣{{ limitDiscountCountdown }}</view> -->
 								<view class="stock_warning" v-if="item.isStock&&item.stockNumber<=10">
@@ -204,11 +203,10 @@
 									<image class="goodsImg"
 										src="https://czg-qr-order.oss-cn-beijing.aliyuncs.com/index/1.gif" mode=""
 										v-else :lazy-load="true"></image>
-										<view class="limitDiscount" v-if="showLimitDiscount(item1)"
-										  >限时折扣{{ limitDiscountCountdown }}</view
-										>
-									
-								<!-- 	<view class="limitDiscount" v-if="item1.is_time_discount">
+									<view class="limitDiscount" v-if="showLimitDiscount(item1)">
+										限时折扣{{ limitDiscountCountdown }}</view>
+
+									<!-- 	<view class="limitDiscount" v-if="item1.is_time_discount">
 										限时折扣{{ limitDiscountCountdown }}</view> -->
 									<view class="stock_warning" v-if="item1.isStock&&item1.stockNumber<=10">
 										仅剩{{item1.stockNumber}}份</view>
@@ -239,7 +237,7 @@
 									<view class="name">{{ item1.name }}</view>
 									<!-- <view class="lookBack" v-if="index=='0'">本店销量第{{index1+1}}名</view>-->
 									<!-- <view class="lookBack" v-if="specifications.item.isHot == 1">热销</view> -->
-									<view class="lookBack"  v-if="returnIsHot(item1,item,index)">热销</view>
+									<view class="lookBack" v-if="returnIsHot(item1,item,index)">热销</view>
 									<view class="describe">{{ item1.shortTitle ? item1.shortTitle : '' }}</view>
 
 									<view class="describe" v-if="item1.suitNum > 1 && item1.type != 'sku'"
@@ -272,10 +270,10 @@
 													:shopUserInfo="shopUserInfo" :shopInfo="shopInfo"></GoodsPrice>
 											</view>
 											<text class="money_num" v-if="item1.unitName">/{{ item1.unitName }}</text>
-											
+
 											<text class="old-price"
 												v-if="showLimitDiscount(item1)">￥{{ item1.salePrice }}</text>
-												<!-- <text class="old-price"
+											<!-- <text class="old-price"
 													v-if="item1.is_time_discount">￥{{ item1.salePrice }}</text> -->
 											<!-- <text v-if="item1.suitNum>1 && item1.type!= 'sku'"
 												style="font-size: 14rpx;">
@@ -327,9 +325,9 @@
 		<shopindex ref="showShopInfoRef"></shopindex>
 		<!-- 购物车 -->
 		<shoppingCartes :cartLists_count="cartLists_count" :cartList="matchedProducts" :showCart="showCart"
-			:limitDiscount="cartStore.limitTimeDiscount" @customevent="websocketsendMessage" @close="showCart = !showCart"
-			:orderinfo="orderinfo" @clickcancelOrder="clickcancelOrder" v-if="cartLists_count > 0"
-			:nextFullAmountActivty="nextFullAmountActivty"></shoppingCartes>
+			:limitDiscount="cartStore.limitTimeDiscount" @customevent="websocketsendMessage"
+			@close="showCart = !showCart" :orderinfo="orderinfo" @clickcancelOrder="clickcancelOrder"
+			v-if="cartLists_count > 0" :nextFullAmountActivty="nextFullAmountActivty"></shoppingCartes>
 
 		<!-- 显示购物车栏 -->
 		<view class="cart-wrap" v-if="cartLists_count > 0 && !confirmordershow && isBusinessTime">
@@ -446,8 +444,9 @@
 							v-if="specifications.item.type != 'package' && specifications.item.result">
 							<text class="i">￥</text>
 							<view class="num">
-								<GoodsPrice :limitDiscount="cartStore.limitTimeDiscount" :cart="specifications.item.result"
-									:shopUserInfo="shopUserInfo" :shopInfo="shopInfo"></GoodsPrice>
+								<GoodsPrice :limitDiscount="cartStore.limitTimeDiscount"
+									:cart="specifications.item.result" :shopUserInfo="shopUserInfo"
+									:shopInfo="shopInfo"></GoodsPrice>
 							</view>
 
 							<text class="num" v-if="false">
@@ -481,7 +480,8 @@
 								v-if="specifications.item.suitNum > 1">「{{ specifications.item.suitNum }}{{ specifications.item.unitName }}起点」</text>
 						</view>
 
-						<view class="operation-wrap" v-if="specifications.item.type != 'package'&&stockNumberIsFull(specifications.item)">
+						<view class="operation-wrap"
+							v-if="specifications.item.type != 'package'&&stockNumberIsFull(specifications.item)">
 							<view class="btn">
 								<up-icon name="minus-circle-fill" color="#E9AB7A" size="25"
 									v-if="shopCartNumber > 0"></up-icon>
@@ -521,8 +521,8 @@
 							</view>
 						</template>
 					</template>
-					
-					
+
+
 				</view>
 			</view>
 		</up-popup>
@@ -1101,10 +1101,10 @@
 			}
 		}
 	};
-	
+
 	//返回是否是热销商品
-	function returnIsHot(item,category,index){
-		return item.isHot&& category.name=='热销' &&index==0 && shopProductList.hots.find(v=>v.id==item.id) 
+	function returnIsHot(item, category, index) {
+		return item.isHot && category.name == '热销' && index == 0 && shopProductList.hots.find(v => v.id == item.id)
 	}
 
 
@@ -1360,15 +1360,15 @@
 
 		return isInRange;
 	};
-	
-	
-	function stockNumberIsFull(item){
-		if(item.isStock && item.stockNumber < item.suitNum){
+
+
+	function stockNumberIsFull(item) {
+		if (item.isStock && item.stockNumber < item.suitNum) {
 			return false
 		}
 		return true
 	}
-	
+
 	/**
 	 * 判断商品是否可售
 	 * @param {Object} item
@@ -1380,7 +1380,7 @@
 			});
 			return false;
 		}
-		if ( item.isStock && item.stockNumber < item.suitNum && i == '+') {
+		if (item.isStock && item.stockNumber < item.suitNum && i == '+') {
 			uni.showToast({
 				title: '库存不足',
 				icon: 'none'
@@ -1430,7 +1430,7 @@
 			number: await calculateValue(item.cartNumber, i, suitNum),
 			is_print: 1,
 			product_type: item.type,
-			is_time_discount: showLimitDiscount(item) 
+			is_time_discount: showLimitDiscount(item)
 		};
 		if (item.cartListId) {
 			sendMsg.id = item.cartListId;
@@ -1608,7 +1608,7 @@
 			// 初始化
 			if (Message.operate_type == 'init') {
 				cartStore.limitTimeDiscount = Message.time_dis_info;
-				console.log('onMessage：限时折扣',cartStore.limitTimeDiscount)
+				console.log('onMessage：限时折扣', cartStore.limitTimeDiscount)
 				cartInit(Message.data)
 
 				uni.hideLoading();
@@ -1629,7 +1629,7 @@
 					cancelText: '舍弃',
 					confirmText: '合并',
 					success(res) {
-						showTableInfoPeopleNumPopup.value=false;
+						showTableInfoPeopleNumPopup.value = false;
 						if (res.confirm) {
 							startUseTable({
 								is_hb: 2
@@ -1669,7 +1669,7 @@
 					shop_id: uni.cache.get('shopId'),
 					time_dis_info: cartStore.limitTimeDiscount
 				};
-
+				console.log('cartStore.limitTimeDiscount', cartStore.limitTimeDiscount)
 				useSocket.sendMessage({
 					type: 'shopping',
 					operate_type: 'time_discount_save',
@@ -1741,7 +1741,7 @@
 					}
 				});
 			}
-			
+
 			if (Message.operate_type == 'time_discount_save') {
 				cartStore.limitTimeDiscount = Message.data;
 			}
@@ -1890,8 +1890,9 @@
 						}
 					});
 				}
-				console.log('limitTimeDiscountRes',item)
-				if (cartStore.limitTimeDiscount && cartStore.limitTimeDiscount.id && item.cartListinfo.is_time_discount ==
+				console.log('limitTimeDiscountRes', item)
+				if (cartStore.limitTimeDiscount && cartStore.limitTimeDiscount.id && item.cartListinfo
+					.is_time_discount ==
 					1) {
 					//限时折扣
 					const price = limitUtils.returnPrice({
@@ -1901,7 +1902,7 @@
 						shopUserInfo: shopUserInfo.value,
 						idKey: 'id'
 					});
-					console.log('限时折扣',price)
+					console.log('限时折扣', price)
 					return total + parseFloat(price) * parseFloat(item.cartNumber);
 				}
 				// 是否启用会员价 0否1是
@@ -2301,10 +2302,13 @@
 			extraInitPar.order_id = e.order_id
 			extraInitPar.user_id = uni.cache.get('userInfo').id || ''
 		}
+		
+		const time_dis_info= await getLimitDiscount()
 
 		useSocket.connect({
 			...options.initMessage,
-			...extraInitPar
+			...extraInitPar,
+			time_dis_info
 		}, onMessage);
 
 
@@ -2351,9 +2355,9 @@
 
 	function showLimitDiscount(item) {
 		if (!cartStore.limitTimeDiscount || !cartStore.limitTimeDiscount.id) {
-			return false;
+			return 0;
 		}
-		return limitUtils.canUseLimitTimeDiscount(item, cartStore.limitTimeDiscount, shopInfo, shopUserInfo.value, 'id');
+		return limitUtils.canUseLimitTimeDiscount(item, cartStore.limitTimeDiscount, shopInfo, shopUserInfo.value, 'id')?1:0;
 	}
 
 	function returnLimitPrice(item) {
@@ -2471,6 +2475,29 @@
 		return 0
 	})
 	const oldOrder = ref(null);
+	
+	// 限时折扣
+	async function getLimitDiscount(){
+		
+		const limitRes = await limitTimeDiscountapi.getConfig({
+			shopId: uni.cache.get('shopId')
+		});
+		if (limitRes && typeof limitRes == 'object') {
+			cartStore.limitTimeDiscount = limitRes;
+		} else {
+			cartStore.limitTimeDiscount = null;
+		}
+		return cartStore.limitTimeDiscount
+		websocketsendMessage({
+			type: 'shopping',
+			operate_type: 'time_discount_save',
+			table_code: uni.cache.get('tableCode'),
+			shop_id: uni.cache.get('shopId'),
+			operate_type: 'time_discount_save',
+			data: cartStore.limitTimeDiscount
+		});
+		console.log('onMounted:限时折扣', cartStore.limitTimeDiscount);
+	}
 	onMounted(async () => {
 		await proxy.$onLaunched;
 		// 获取当前页面栈
@@ -2484,37 +2511,11 @@
 		getNewUserDiscount();
 		// 满减活动
 		getDiscountActivity();
+		
 		let res = await APIhistoryOrder({
 			tableCode: uni.cache.get('tableCode')
 		});
 		oldOrder.value = res;
-		const limitRes = await limitTimeDiscountapi.getConfig({
-			shopId: uni.cache.get('shopId')
-		});
-		if (limitRes && typeof limitRes == 'object') {
-			cartStore.limitTimeDiscount = limitRes;
-			console.log('onMounted:限时折扣',cartStore.limitTimeDiscount );
-			websocketsendMessage({
-				type: 'shopping',
-				operate_type: 'time_discount_save',
-				table_code: uni.cache.get('tableCode'),
-				shop_id: uni.cache.get('shopId'),
-				operate_type: 'time_discount_save',
-				data: limitRes
-			});
-		} else {
-			cartStore.limitTimeDiscount = null;
-			console.log('onMounted:限时折扣',cartStore.limitTimeDiscount );
-			websocketsendMessage({
-				type: 'shopping',
-				operate_type: 'time_discount_save',
-				table_code: uni.cache.get('tableCode'),
-				shop_id: uni.cache.get('shopId'),
-				operate_type: 'time_discount_save',
-				data: null
-			});
-		}
-
 		await productqueryProduct();
 		if (res && res.id && shopInfo.registerType == 'after') {
 			toHistory();
diff --git a/stores/carts.js b/stores/carts.js
index ed69114..2a26f34 100644
--- a/stores/carts.js
+++ b/stores/carts.js
@@ -319,6 +319,9 @@ export const useCartsStore = defineStore("cart", () => {
 	//购物车商品信息补全初始化
 	function cartsGoodsInfoInit(arr) {
 		console.log('cartsGoodsInfoInit', arr)
+		if(oldOrder.value&&oldOrder.value.status=='done'){
+			return ''
+		}
 		carts.value = arr
 			.map((v) => {