@pisell/pisellos 0.0.567 → 0.0.568

package/lib/solution/ShopDiscount/utils.js

@@ -1,88 +1,97 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/solution/ShopDiscount/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  calculateOrderLevelDiscountAllocation: () => calculateOrderLevelDiscountAllocation,
-  filterDiscountListByBookingTime: () => filterDiscountListByBookingTime,
-  getDateIsInSchedule: () => getDateIsInSchedule,
-  getDiscountAmount: () => getDiscountAmount,
-  getDiscountListAmount: () => getDiscountListAmount,
-  getDiscountListAmountTotal: () => getDiscountListAmountTotal,
-  isAllNormalProduct: () => isAllNormalProduct,
-  isNormalProductByDurationSchedule: () => isNormalProductByDurationSchedule,
-  isOrderLevelFixedAmountDiscount: () => isOrderLevelFixedAmountDiscount,
-  uniqueById: () => uniqueById
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(utils_exports);
-var import_decimal = __toESM(require("decimal.js"));
-var import_dayjs = __toESM(require("dayjs"));
-var uniqueById = (arr, key = "id") => {
-  const seen = /* @__PURE__ */ new Set();
-  return arr.filter((item) => !seen.has(item[key]) && seen.add(item[key]));
+exports.uniqueById = exports.isOrderLevelFixedAmountDiscount = exports.isNormalProductByDurationSchedule = exports.isAllNormalProduct = exports.getDiscountListAmountTotal = exports.getDiscountListAmount = exports.getDiscountAmount = exports.getDateIsInSchedule = exports.filterDiscountListByBookingTime = exports.calculateOrderLevelDiscountAllocation = void 0;
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _dayjs = _interopRequireDefault(require("dayjs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const uniqueById = (arr, key = 'id') => {
+  const seen = new Set();
+  return arr.filter(item => !seen.has(item[key]) && seen.add(item[key]));
 };
-var isNormalProductByDurationSchedule = (item) => {
-  var _a, _b;
-  return !(item == null ? void 0 : item.duration) && !((_a = item == null ? void 0 : item.schedules) == null ? void 0 : _a.length) && !((_b = item == null ? void 0 : item["schedule.ids"]) == null ? void 0 : _b.length);
+
+// 非预约商品 通过时长和日程判断是否是普通商品
+exports.uniqueById = uniqueById;
+const isNormalProductByDurationSchedule = item => {
+  return !item?.duration && !item?.schedules?.length && !item?.['schedule.ids']?.length;
 };
-var isAllNormalProduct = (items) => {
-  return items.every((item) => isNormalProductByDurationSchedule(item));
+
+// 是否全部是普通商品
+exports.isNormalProductByDurationSchedule = isNormalProductByDurationSchedule;
+const isAllNormalProduct = items => {
+  return items.every(item => isNormalProductByDurationSchedule(item));
 };
-var getDiscountAmount = (discount, total, price) => {
-  var _a;
-  if (discount.tag === "good_pass") {
-    return new import_decimal.default(price).minus(new import_decimal.default(price || 0)).toNumber();
+
+/**
+ * 获取折扣金额 基于折扣卡类型计算 
+ * 商品券：直接返回商品价格
+ * 折扣卡：根据折扣卡类型计算 固定金额：直接返回折扣卡金额 百分比：根据折扣卡金额计算
+ * @param discount 
+ * @param total 
+ * @param price 
+ * @returns 
+ */
+/**
+ * 获取折扣金额 基于折扣卡类型计算 
+ * 商品券：直接返回商品价格
+ * 折扣卡：根据折扣卡类型计算 固定金额：直接返回折扣卡金额 百分比：根据折扣卡金额计算
+ * @param discount 
+ * @param total 
+ * @param price 
+ * @returns 
+ */
+exports.isAllNormalProduct = isAllNormalProduct;
+const getDiscountAmount = (discount, total, price) => {
+  // 商品券
+  if (discount.tag === 'good_pass') {
+    return new _decimal.default(price).minus(new _decimal.default(price || 0)).toNumber();
   }
-  const isFixedAmount = ((_a = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a.discount_card_type) === "fixed_amount";
+
+  // 判断是否是固定金额
+  const isFixedAmount = discount?.metadata?.discount_card_type === 'fixed_amount';
+
+  // 固定金额 小于0时返回0
   if (isFixedAmount) {
-    return Math.max(new import_decimal.default(price).minus(new import_decimal.default((discount.amount ?? discount.par_value) || 0)).toNumber(), 0);
+    return Math.max(new _decimal.default(price).minus(new _decimal.default((discount.amount ?? discount.par_value) || 0)).toNumber(), 0);
   }
-  return new import_decimal.default(100).minus(discount.par_value || 0).div(100).mul(new import_decimal.default(price)).toNumber();
+
+  // 百分比：根据折扣卡金额计算
+  return new _decimal.default(100).minus(discount.par_value || 0).div(100).mul(new _decimal.default(price)).toNumber();
 };
-var getDiscountListAmountTotal = (discount) => {
+exports.getDiscountAmount = getDiscountAmount;
+const getDiscountListAmountTotal = discount => {
   return discount.reduce((acc, cur) => {
-    return new import_decimal.default(acc).plus(new import_decimal.default(cur.num || 1).mul(new import_decimal.default(cur.amount || 0))).toNumber();
-  }, new import_decimal.default(0));
+    return new _decimal.default(acc).plus(new _decimal.default(cur.num || 1).mul(new _decimal.default(cur.amount || 0))).toNumber();
+  }, new _decimal.default(0));
 };
-var getDiscountListAmount = (discount) => {
+
+/**
+ * 获取折扣金额 计算每个折扣的金额
+ * @param discount
+ * @returns
+ */
+exports.getDiscountListAmountTotal = getDiscountListAmountTotal;
+const getDiscountListAmount = discount => {
   return discount.reduce((acc, cur) => {
-    return new import_decimal.default(acc).plus(new import_decimal.default(cur.amount || 0)).toNumber();
-  }, new import_decimal.default(0));
+    return new _decimal.default(acc).plus(new _decimal.default(cur.amount || 0)).toNumber();
+  }, new _decimal.default(0));
 };
-var getDateIsInSchedule = (dateTime, scheduleList) => {
+
+// 日程项接口定义
+exports.getDiscountListAmount = getDiscountListAmount;
+// 获取时间是否在日程范围内
+const getDateIsInSchedule = (dateTime, scheduleList) => {
   if (!dateTime || !scheduleList || scheduleList.length === 0) {
     return false;
   }
-  const targetDate = (0, import_dayjs.default)(dateTime);
+  const targetDate = (0, _dayjs.default)(dateTime);
   if (!targetDate.isValid()) {
     return false;
   }
+
+  // 遍历所有日程项
   for (const schedule of scheduleList) {
     if (isTimeInScheduleItem(dateTime, schedule)) {
       return true;
@@ -90,284 +99,422 @@ var getDateIsInSchedule = (dateTime, scheduleList) => {
   }
   return false;
 };
-var isTimeInScheduleItem = (dateTime, schedule) => {
-  const targetDate = (0, import_dayjs.default)(dateTime);
-  const targetDateString = dateTime.split(" ")[0];
-  const targetTimeString = dateTime.split(" ")[1] || "00:00:00";
+
+// 判断时间是否在单个日程项范围内
+exports.getDateIsInSchedule = getDateIsInSchedule;
+const isTimeInScheduleItem = (dateTime, schedule) => {
+  const targetDate = (0, _dayjs.default)(dateTime);
+  const targetDateString = dateTime.split(' ')[0]; // YYYY-MM-DD
+  const targetTimeString = dateTime.split(' ')[1] || '00:00:00'; // HH:mm:ss
+
   switch (schedule.type) {
-    case "standard":
+    case 'standard':
       return isInStandardSchedule(targetDate, targetDateString, targetTimeString, schedule);
-    case "time-slots":
+    case 'time-slots':
       return isInTimeSlotsSchedule(targetDate, targetDateString, targetTimeString, schedule);
-    case "designation":
+    case 'designation':
       return isInDesignationSchedule(targetDate, targetDateString, targetTimeString, schedule);
     default:
       return false;
   }
 };
-var isInStandardSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+
+// 处理标准类型日程
+const isInStandardSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.start_time || !schedule.end_time) {
     return false;
   }
-  const startDate = (0, import_dayjs.default)(schedule.start_time);
-  const endDate = (0, import_dayjs.default)(schedule.end_time);
+  const startDate = (0, _dayjs.default)(schedule.start_time);
+  const endDate = (0, _dayjs.default)(schedule.end_time);
+
+  // 先检查是否在基础时间范围内（不考虑重复）
   const isInBasicRange = targetDate.isSameOrAfter(startDate) && targetDate.isSameOrBefore(endDate);
-  if (schedule.repeat_type === "none") {
+  if (schedule.repeat_type === 'none') {
     return isInBasicRange;
   }
+
+  // 处理重复日程
   return isInRepeatingSchedule(targetDate, targetDateString, targetTimeString, schedule, startDate, endDate);
 };
-var isInTimeSlotsSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+
+// 处理时间段类型日程
+const isInTimeSlotsSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.start_time) {
     return false;
   }
-  if (schedule.repeat_type === "none") {
-    const scheduleDate = schedule.start_time.split(" ")[0];
+
+  // 如果不重复，使用原有逻辑
+  if (schedule.repeat_type === 'none') {
+    const scheduleDate = schedule.start_time.split(' ')[0];
+
+    // 检查日期是否匹配
     if (targetDateString !== scheduleDate) {
       return false;
     }
+
+    // 检查是否在任一时间段内
     return checkTimeSlotsForDate(targetDate, targetDateString, schedule.time_slot);
   }
+
+  // 处理重复日程
   return isInTimeSlotsRepeatingSchedule(targetDate, targetDateString, targetTimeString, schedule);
 };
-var isInDesignationSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+
+// 处理指定类型日程
+const isInDesignationSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.designation) {
     return false;
   }
   for (const designation of schedule.designation) {
     const startDateTime = `${designation.start_date} ${designation.start_time}:00`;
     const endDateTime = `${designation.end_date} ${designation.end_time}:00`;
-    const startDate = (0, import_dayjs.default)(startDateTime);
-    const endDate = (0, import_dayjs.default)(endDateTime);
+    const startDate = (0, _dayjs.default)(startDateTime);
+    const endDate = (0, _dayjs.default)(endDateTime);
     if (targetDate.isSameOrAfter(startDate) && targetDate.isSameOrBefore(endDate)) {
       return true;
     }
   }
   return false;
 };
-var isInRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule, startDate, endDate) => {
+
+// 处理重复日程逻辑
+const isInRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule, startDate, endDate) => {
   if (!schedule.repeat_rule) {
     return false;
   }
-  const { repeat_rule, repeat_type } = schedule;
-  const targetDateOnly = (0, import_dayjs.default)(targetDateString);
+  const {
+    repeat_rule,
+    repeat_type
+  } = schedule;
+  const targetDateOnly = (0, _dayjs.default)(targetDateString); // 只取日期部分
+
+  // 首先检查是否在包含日期中（包含日期是额外增加的有效日期）
   if (repeat_rule.included_date && repeat_rule.included_date.length > 0) {
     for (const includedDate of repeat_rule.included_date) {
-      const includeStartDate = (0, import_dayjs.default)(includedDate.start);
-      const includeEndDate = (0, import_dayjs.default)(includedDate.end);
-      if (targetDateOnly.isSameOrAfter(includeStartDate, "day") && targetDateOnly.isSameOrBefore(includeEndDate, "day")) {
+      const includeStartDate = (0, _dayjs.default)(includedDate.start);
+      const includeEndDate = (0, _dayjs.default)(includedDate.end);
+      if (targetDateOnly.isSameOrAfter(includeStartDate, 'day') && targetDateOnly.isSameOrBefore(includeEndDate, 'day')) {
+        // 在包含日期中，直接返回true，无需检查其他条件
         return true;
       }
     }
   }
+
+  // 检查是否在排除日期中
   for (const excludedDate of repeat_rule.excluded_date) {
-    const excludeStartDate = (0, import_dayjs.default)(excludedDate.start);
-    const excludeEndDate = (0, import_dayjs.default)(excludedDate.end);
-    if (targetDateOnly.isSameOrAfter(excludeStartDate, "day") && targetDateOnly.isSameOrBefore(excludeEndDate, "day")) {
+    const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
+    const excludeEndDate = (0, _dayjs.default)(excludedDate.end);
+    // 检查目标日期是否在排除范围内（包含边界）
+    if (targetDateOnly.isSameOrAfter(excludeStartDate, 'day') && targetDateOnly.isSameOrBefore(excludeEndDate, 'day')) {
       return false;
     }
   }
-  if (repeat_rule.end.type === "date" && repeat_rule.end.end_date) {
-    const ruleEndDate = (0, import_dayjs.default)(repeat_rule.end.end_date);
+
+  // 检查重复规则的结束条件
+  if (repeat_rule.end.type === 'date' && repeat_rule.end.end_date) {
+    const ruleEndDate = (0, _dayjs.default)(repeat_rule.end.end_date);
     if (targetDate.isAfter(ruleEndDate)) {
       return false;
     }
   }
+
+  // 根据重复类型检查
   switch (repeat_type) {
-    case "daily":
+    case 'daily':
       return isInDailyRepeat(targetDate, startDate, endDate, repeat_rule);
-    case "weekly":
+    case 'weekly':
       return isInWeeklyRepeat(targetDate, startDate, endDate, repeat_rule);
     default:
       return false;
+    // 不支持月和年重复
   }
 };
-var isInDailyRepeat = (targetDate, startDate, endDate, repeatRule) => {
-  const daysDiff = targetDate.diff(startDate, "day");
+
+// 每日重复逻辑
+const isInDailyRepeat = (targetDate, startDate, endDate, repeatRule) => {
+  const daysDiff = targetDate.diff(startDate, 'day');
   if (daysDiff < 0) {
     return false;
   }
+
+  // 检查频率
   if (daysDiff % repeatRule.frequency !== 0) {
     return false;
   }
+
+  // 检查时间是否在日程的时间范围内
   const targetTimeOfDay = targetDate.hour() * 3600 + targetDate.minute() * 60 + targetDate.second();
   const startTimeOfDay = startDate.hour() * 3600 + startDate.minute() * 60 + startDate.second();
   const endTimeOfDay = endDate.hour() * 3600 + endDate.minute() * 60 + endDate.second();
+
+  // 每日重复：每天都在相同的时间段内有效
+  // 例如：01:00:00 - 16:00:00，每天都是这个时间段
   return targetTimeOfDay >= startTimeOfDay && targetTimeOfDay <= endTimeOfDay;
 };
-var isInWeeklyRepeat = (targetDate, startDate, endDate, repeatRule) => {
-  const targetDayOfWeek = targetDate.day();
+
+// 每周重复逻辑
+const isInWeeklyRepeat = (targetDate, startDate, endDate, repeatRule) => {
+  const targetDayOfWeek = targetDate.day(); // 0=周日, 1=周一, ..., 6=周六
+
+  // 检查是否在指定的星期几内
   if (!repeatRule.frequency_date.includes(targetDayOfWeek)) {
     return false;
   }
-  const weeksDiff = targetDate.diff(startDate, "week");
+
+  // 计算周差
+  const weeksDiff = targetDate.diff(startDate, 'week');
   if (weeksDiff < 0) {
     return false;
   }
+
+  // 检查频率
   if (weeksDiff % repeatRule.frequency !== 0) {
     return false;
   }
+
+  // 检查时间是否在日程的时间范围内
   const targetTimeOfDay = targetDate.hour() * 3600 + targetDate.minute() * 60 + targetDate.second();
   const startTimeOfDay = startDate.hour() * 3600 + startDate.minute() * 60 + startDate.second();
   const endTimeOfDay = endDate.hour() * 3600 + endDate.minute() * 60 + endDate.second();
   return targetTimeOfDay >= startTimeOfDay && targetTimeOfDay <= endTimeOfDay;
 };
-var isInTimeSlotsRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+
+// 处理 time-slots 类型的重复日程
+const isInTimeSlotsRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.repeat_rule || !schedule.start_time) {
     return false;
   }
-  const { repeat_rule, repeat_type } = schedule;
-  const startDate = (0, import_dayjs.default)(schedule.start_time);
-  const targetDateOnly = (0, import_dayjs.default)(targetDateString);
+  const {
+    repeat_rule,
+    repeat_type
+  } = schedule;
+  const startDate = (0, _dayjs.default)(schedule.start_time);
+  const targetDateOnly = (0, _dayjs.default)(targetDateString);
+
+  // 检查包含日期
   if (repeat_rule.included_date && repeat_rule.included_date.length > 0) {
     for (const includedDate of repeat_rule.included_date) {
-      const includeStartDate = (0, import_dayjs.default)(includedDate.start);
-      const includeEndDate = (0, import_dayjs.default)(includedDate.end);
-      if (targetDateOnly.isSameOrAfter(includeStartDate, "day") && targetDateOnly.isSameOrBefore(includeEndDate, "day")) {
+      const includeStartDate = (0, _dayjs.default)(includedDate.start);
+      const includeEndDate = (0, _dayjs.default)(includedDate.end);
+      if (targetDateOnly.isSameOrAfter(includeStartDate, 'day') && targetDateOnly.isSameOrBefore(includeEndDate, 'day')) {
+        // 在包含日期中，检查时间段
         return checkTimeSlotsForDate(targetDate, targetDateString, schedule.time_slot);
       }
     }
   }
+
+  // 检查排除日期
   for (const excludedDate of repeat_rule.excluded_date) {
-    const excludeStartDate = (0, import_dayjs.default)(excludedDate.start);
-    const excludeEndDate = (0, import_dayjs.default)(excludedDate.end);
-    if (targetDateOnly.isSameOrAfter(excludeStartDate, "day") && targetDateOnly.isSameOrBefore(excludeEndDate, "day")) {
+    const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
+    const excludeEndDate = (0, _dayjs.default)(excludedDate.end);
+    if (targetDateOnly.isSameOrAfter(excludeStartDate, 'day') && targetDateOnly.isSameOrBefore(excludeEndDate, 'day')) {
       return false;
     }
   }
-  if (repeat_rule.end.type === "date" && repeat_rule.end.end_date) {
-    const ruleEndDate = (0, import_dayjs.default)(repeat_rule.end.end_date);
-    if (targetDateOnly.isAfter(ruleEndDate, "day")) {
+
+  // 检查重复规则的结束条件
+  if (repeat_rule.end.type === 'date' && repeat_rule.end.end_date) {
+    const ruleEndDate = (0, _dayjs.default)(repeat_rule.end.end_date);
+    if (targetDateOnly.isAfter(ruleEndDate, 'day')) {
       return false;
     }
   }
+
+  // 检查目标日期是否在重复规则范围内
   let isDateValid = false;
   switch (repeat_type) {
-    case "daily":
+    case 'daily':
       isDateValid = isInDailyRepeatForDate(targetDateOnly, startDate, repeat_rule);
       break;
-    case "weekly":
+    case 'weekly':
       isDateValid = isInWeeklyRepeatForDate(targetDateOnly, startDate, repeat_rule);
       break;
     default:
       return false;
   }
+
+  // 如果日期有效，检查时间段
   if (isDateValid) {
     return checkTimeSlotsForDate(targetDate, targetDateString, schedule.time_slot);
   }
   return false;
 };
-var checkTimeSlotsForDate = (targetDate, targetDateString, timeSlots) => {
+
+// 检查目标时间是否在某个时间段内（使用目标日期 + time_slot 时间）
+const checkTimeSlotsForDate = (targetDate, targetDateString, timeSlots) => {
   for (const timeSlot of timeSlots) {
     const slotStart = `${targetDateString} ${timeSlot.start_time}:00`;
     const slotEnd = `${targetDateString} ${timeSlot.end_time}:00`;
-    const slotStartDate = (0, import_dayjs.default)(slotStart);
-    const slotEndDate = (0, import_dayjs.default)(slotEnd);
+    const slotStartDate = (0, _dayjs.default)(slotStart);
+    const slotEndDate = (0, _dayjs.default)(slotEnd);
     if (targetDate.isSameOrAfter(slotStartDate) && targetDate.isSameOrBefore(slotEndDate)) {
       return true;
     }
   }
   return false;
 };
-var isInDailyRepeatForDate = (targetDate, startDate, repeatRule) => {
-  const daysDiff = targetDate.diff(startDate, "day");
+
+// 检查日期是否满足每日重复规则（只检查日期，不检查时间）
+const isInDailyRepeatForDate = (targetDate, startDate, repeatRule) => {
+  const daysDiff = targetDate.diff(startDate, 'day');
   if (daysDiff < 0) {
     return false;
   }
+
+  // 检查频率
   return daysDiff % repeatRule.frequency === 0;
 };
-var isInWeeklyRepeatForDate = (targetDate, startDate, repeatRule) => {
-  const targetDayOfWeek = targetDate.day();
+
+// 检查日期是否满足每周重复规则（只检查日期，不检查时间）
+const isInWeeklyRepeatForDate = (targetDate, startDate, repeatRule) => {
+  const targetDayOfWeek = targetDate.day(); // 0=周日, 1=周一, ..., 6=周六
+
+  // 检查是否在指定的星期几内
   if (!repeatRule.frequency_date.includes(targetDayOfWeek)) {
     return false;
   }
-  const weeksDiff = targetDate.diff(startDate, "week");
+
+  // 计算周差
+  const weeksDiff = targetDate.diff(startDate, 'week');
   if (weeksDiff < 0) {
     return false;
   }
+
+  // 检查频率
   return weeksDiff % repeatRule.frequency === 0;
 };
-var filterDiscountListByBookingTime = (discountList, bookingTime) => {
+
+/**
+ * 根据预约时间过滤优惠券列表
+ * @param discountList 优惠券列表
+ * @param bookingTime 预约时间 (格式: YYYY-MM-DD HH:mm:ss)
+ * @returns 过滤后的优惠券列表
+ */
+const filterDiscountListByBookingTime = (discountList, bookingTime) => {
   if (!bookingTime) {
     return discountList;
   }
-  return discountList.filter((discount) => {
-    var _a, _b;
-    if (((_a = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a.validity_type) === "custom_schedule_validity") {
-      return getDateIsInSchedule(bookingTime, ((_b = discount.custom_schedule_snapshot) == null ? void 0 : _b.data) || []);
+  return discountList.filter(discount => {
+    if (discount?.metadata?.validity_type === "custom_schedule_validity") {
+      return getDateIsInSchedule(bookingTime, discount.custom_schedule_snapshot?.data || []);
     }
     try {
       const isHasStart = !!discount.start_date && !!discount.start_time;
-      const startDate = (0, import_dayjs.default)(`${discount.start_date} ${discount.start_time}`);
-      const bookingTimeDayjs = (0, import_dayjs.default)(bookingTime);
+      const startDate = (0, _dayjs.default)(`${discount.start_date} ${discount.start_time}`);
+      const bookingTimeDayjs = (0, _dayjs.default)(bookingTime);
+
+      // 判断预约时间是否在开始时间之后
       const isAfterStart = isHasStart ? bookingTimeDayjs.isSameOrAfter(startDate) : true;
-      const isBeforeExpire = discount.expire_time ? bookingTimeDayjs.isSameOrBefore((0, import_dayjs.default)(discount.expire_time)) : true;
+
+      // 判断预约时间是否在过期时间之前（expire_time 为空时为长期有效）
+      const isBeforeExpire = discount.expire_time ? bookingTimeDayjs.isSameOrBefore((0, _dayjs.default)(discount.expire_time)) : true;
       return isAfterStart && isBeforeExpire;
     } catch (error) {
       return true;
     }
   });
 };
-var isOrderLevelFixedAmountDiscount = (discount) => {
-  var _a, _b;
-  return discount.tag === "product_discount_card" && ((_a = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a.discount_card_type) === "fixed_amount" && ((_b = discount == null ? void 0 : discount.metadata) == null ? void 0 : _b.discount_calculation_mode) === "order_level";
+/**
+ * 判断是否是订单级别的固定金额折扣卡
+ * @param discount 折扣
+ * @returns 是否是订单级别的固定金额折扣卡
+ */
+exports.filterDiscountListByBookingTime = filterDiscountListByBookingTime;
+const isOrderLevelFixedAmountDiscount = discount => {
+  return discount.tag === 'product_discount_card' && discount?.metadata?.discount_card_type === 'fixed_amount' && discount?.metadata?.discount_calculation_mode === 'order_level';
 };
-var calculateOrderLevelDiscountAllocation = (discount, applicableProducts) => {
-  const result = /* @__PURE__ */ new Map();
+
+/**
+ * 计算订单级别固定金额折扣卡的分摊结果
+ * @param discount 折扣卡
+ * @param applicableProducts 适用商品列表 { productId, amount, quantity, parentQuantity }
+ * @returns 分摊结果 Map<productId, { discountAmount, difference }>
+ * 注意：
+ * - discountAmount 是单价折扣金额（不是总折扣金额）
+ * - difference（总差值）优先直接加到数量为1的单商品折扣上，如果没有则存储在metadata中
+ */
+exports.isOrderLevelFixedAmountDiscount = isOrderLevelFixedAmountDiscount;
+const calculateOrderLevelDiscountAllocation = (discount, applicableProducts) => {
+  const result = new Map();
   if (applicableProducts.length === 0) {
     return result;
   }
+
+  // 计算适用商品的总金额（数量 × 单价）
   const totalAmount = applicableProducts.reduce((acc, product) => {
-    return new import_decimal.default(acc).plus(new import_decimal.default(product.amount).mul(product.quantity)).toNumber();
+    return new _decimal.default(acc).plus(new _decimal.default(product.amount).mul(product.quantity)).toNumber();
   }, 0);
   if (totalAmount <= 0) {
     return result;
   }
-  const fixedAmount = new import_decimal.default(discount.par_value || 0).toNumber();
+
+  // 固定减免金额
+  const fixedAmount = new _decimal.default(discount.par_value || 0).toNumber();
+
+  // 如果固定金额 >= 商品总金额，折扣最高为商品金额（免费）
   const actualDiscountTotal = Math.min(fixedAmount, totalAmount);
-  let allocatedTotal = new import_decimal.default(0);
-  applicableProducts.forEach((product) => {
-    const rawDiscountPerItem = new import_decimal.default(product.amount).div(totalAmount).mul(actualDiscountTotal);
-    const discountAmountPerItem = rawDiscountPerItem.toDecimalPlaces(2, import_decimal.default.ROUND_DOWN).toNumber();
+
+  // 计算每个商品的单价折扣金额
+  let allocatedTotal = new _decimal.default(0);
+  applicableProducts.forEach(product => {
+    // 🔥 分摊公式改为：(单价 / 适用商品总金额) × 固定金额
+    // 这样只有一次取整，避免精度损失
+    const rawDiscountPerItem = new _decimal.default(product.amount).div(totalAmount).mul(actualDiscountTotal);
+
+    // 保留两位小数，向下取整（单价折扣）
+    const discountAmountPerItem = rawDiscountPerItem.toDecimalPlaces(2, _decimal.default.ROUND_DOWN).toNumber();
     result.set(product.productId, {
       discountAmount: discountAmountPerItem,
       // 单价折扣金额
-      difference: 0
-      // 默认差值为0
+      difference: 0 // 默认差值为0
     });
-    allocatedTotal = allocatedTotal.plus(
-      new import_decimal.default(discountAmountPerItem).mul(product.quantity)
-    );
+
+    // 累加实际分配的总折扣金额（单价折扣 × 数量）
+    allocatedTotal = allocatedTotal.plus(new _decimal.default(discountAmountPerItem).mul(product.quantity));
   });
-  const totalDifference = new import_decimal.default(actualDiscountTotal).minus(allocatedTotal).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
+
+  // 🔥 计算总差值
+  // 总差值 = 固定金额 - 所有商品的 (单价折扣 × 数量) 之和
+  const totalDifference = new _decimal.default(actualDiscountTotal).minus(allocatedTotal).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
   if (totalDifference > 0) {
-    const isSingleQuantity = (product) => {
-      if (product.parentQuantity !== void 0) {
+    // 🔥 判断商品是否是真正的"数量为1"
+    // 主商品：quantity === 1
+    // 子商品：quantity === 1 且 parentQuantity === 1
+    const isSingleQuantity = product => {
+      if (product.parentQuantity !== undefined) {
+        // 子商品：需要同时满足自身数量为1且主商品数量为1
         return product.quantity === 1 && product.parentQuantity === 1;
       }
+      // 主商品：只需要自身数量为1
       return product.quantity === 1;
     };
+
+    // 🔥 筛选出数量为1的商品
     const singleQuantityProducts = applicableProducts.filter(isSingleQuantity);
     if (singleQuantityProducts.length > 0) {
-      const productsWithEnoughSpace = singleQuantityProducts.filter((product) => {
+      // 🔥 优先级1：找到有足够剩余空间且金额最大的商品
+      // 剩余空间 = 商品价格 - 当前折扣金额 >= 差值
+      const productsWithEnoughSpace = singleQuantityProducts.filter(product => {
         const allocation = result.get(product.productId);
-        if (!allocation)
-          return false;
-        const remainingSpace = new import_decimal.default(product.amount).minus(allocation.discountAmount).toNumber();
+        if (!allocation) return false;
+        const remainingSpace = new _decimal.default(product.amount).minus(allocation.discountAmount).toNumber();
         return remainingSpace >= totalDifference;
       });
       if (productsWithEnoughSpace.length > 0) {
+        // 按金额降序排序，选择金额最大的
         productsWithEnoughSpace.sort((a, b) => b.amount - a.amount);
         const targetProduct = productsWithEnoughSpace[0];
         const targetAllocation = result.get(targetProduct.productId);
         if (targetAllocation) {
+          // 差值直接加到折扣金额上
           result.set(targetProduct.productId, {
-            discountAmount: new import_decimal.default(targetAllocation.discountAmount).plus(totalDifference).toNumber(),
-            difference: 0
-            // 不需要存储差值
+            discountAmount: new _decimal.default(targetAllocation.discountAmount).plus(totalDifference).toNumber(),
+            difference: 0 // 不需要存储差值
           });
         }
       } else {
+        // 🔥 优先级2：所有数量为1的商品都没有足够剩余空间
+        // 选择金额最大的商品，差值存储在metadata中
         singleQuantityProducts.sort((a, b) => b.amount - a.amount);
         const targetProduct = singleQuantityProducts[0];
         const targetAllocation = result.get(targetProduct.productId);
@@ -379,6 +526,8 @@ var calculateOrderLevelDiscountAllocation = (discount, applicableProducts) => {
         }
       }
     } else {
+      // 🔥 优先级3：没有数量为1的商品，走原有逻辑
+      // 差值存储在最后一个商品的metadata中
       const lastProduct = applicableProducts[applicableProducts.length - 1];
       const lastProductAllocation = result.get(lastProduct.productId);
       if (lastProductAllocation) {
@@ -391,16 +540,4 @@ var calculateOrderLevelDiscountAllocation = (discount, applicableProducts) => {
   }
   return result;
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  calculateOrderLevelDiscountAllocation,
-  filterDiscountListByBookingTime,
-  getDateIsInSchedule,
-  getDiscountAmount,
-  getDiscountListAmount,
-  getDiscountListAmountTotal,
-  isAllNormalProduct,
-  isNormalProductByDurationSchedule,
-  isOrderLevelFixedAmountDiscount,
-  uniqueById
-});
+exports.calculateOrderLevelDiscountAllocation = calculateOrderLevelDiscountAllocation;