@pisell/pisellos 0.0.569 → 0.10.2

package/lib/solution/ShopDiscount/utils.js

@@ -1,97 +1,88 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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
 });
-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]));
+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 = uniqueById;
-const isNormalProductByDurationSchedule = item => {
-  return !item?.duration && !item?.schedules?.length && !item?.['schedule.ids']?.length;
+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.isNormalProductByDurationSchedule = isNormalProductByDurationSchedule;
-const isAllNormalProduct = items => {
-  return items.every(item => isNormalProductByDurationSchedule(item));
+var isAllNormalProduct = (items) => {
+  return items.every((item) => isNormalProductByDurationSchedule(item));
 };
-
-/**
- * 获取折扣金额 基于折扣卡类型计算 
- * 商品券：直接返回商品价格
- * 折扣卡：根据折扣卡类型计算 固定金额：直接返回折扣卡金额 百分比：根据折扣卡金额计算
- * @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();
+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();
   }
-
-  // 判断是否是固定金额
-  const isFixedAmount = discount?.metadata?.discount_card_type === 'fixed_amount';
-
-  // 固定金额 小于0时返回0
+  const isFixedAmount = ((_a = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a.discount_card_type) === "fixed_amount";
   if (isFixedAmount) {
-    return Math.max(new _decimal.default(price).minus(new _decimal.default((discount.amount ?? discount.par_value) || 0)).toNumber(), 0);
+    return Math.max(new import_decimal.default(price).minus(new import_decimal.default((discount.amount ?? discount.par_value) || 0)).toNumber(), 0);
   }
-
-  // 百分比：根据折扣卡金额计算
-  return new _decimal.default(100).minus(discount.par_value || 0).div(100).mul(new _decimal.default(price)).toNumber();
+  return new import_decimal.default(100).minus(discount.par_value || 0).div(100).mul(new import_decimal.default(price)).toNumber();
 };
-exports.getDiscountAmount = getDiscountAmount;
-const getDiscountListAmountTotal = discount => {
+var getDiscountListAmountTotal = (discount) => {
   return discount.reduce((acc, cur) => {
-    return new _decimal.default(acc).plus(new _decimal.default(cur.num || 1).mul(new _decimal.default(cur.amount || 0))).toNumber();
-  }, new _decimal.default(0));
+    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));
 };
-
-/**
- * 获取折扣金额 计算每个折扣的金额
- * @param discount
- * @returns
- */
-exports.getDiscountListAmountTotal = getDiscountListAmountTotal;
-const getDiscountListAmount = discount => {
+var getDiscountListAmount = (discount) => {
   return discount.reduce((acc, cur) => {
-    return new _decimal.default(acc).plus(new _decimal.default(cur.amount || 0)).toNumber();
-  }, new _decimal.default(0));
+    return new import_decimal.default(acc).plus(new import_decimal.default(cur.amount || 0)).toNumber();
+  }, new import_decimal.default(0));
 };
-
-// 日程项接口定义
-exports.getDiscountListAmount = getDiscountListAmount;
-// 获取时间是否在日程范围内
-const getDateIsInSchedule = (dateTime, scheduleList) => {
+var getDateIsInSchedule = (dateTime, scheduleList) => {
   if (!dateTime || !scheduleList || scheduleList.length === 0) {
     return false;
   }
-  const targetDate = (0, _dayjs.default)(dateTime);
+  const targetDate = (0, import_dayjs.default)(dateTime);
   if (!targetDate.isValid()) {
     return false;
   }
-
-  // 遍历所有日程项
   for (const schedule of scheduleList) {
     if (isTimeInScheduleItem(dateTime, schedule)) {
       return true;
@@ -99,422 +90,284 @@ const getDateIsInSchedule = (dateTime, scheduleList) => {
   }
   return false;
 };
-
-// 判断时间是否在单个日程项范围内
-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
-
+var isTimeInScheduleItem = (dateTime, schedule) => {
+  const targetDate = (0, import_dayjs.default)(dateTime);
+  const targetDateString = dateTime.split(" ")[0];
+  const targetTimeString = dateTime.split(" ")[1] || "00:00:00";
   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;
   }
 };
-
-// 处理标准类型日程
-const isInStandardSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+var isInStandardSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.start_time || !schedule.end_time) {
     return false;
   }
-  const startDate = (0, _dayjs.default)(schedule.start_time);
-  const endDate = (0, _dayjs.default)(schedule.end_time);
-
-  // 先检查是否在基础时间范围内（不考虑重复）
+  const startDate = (0, import_dayjs.default)(schedule.start_time);
+  const endDate = (0, import_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);
 };
-
-// 处理时间段类型日程
-const isInTimeSlotsSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+var 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);
 };
-
-// 处理指定类型日程
-const isInDesignationSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+var 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, _dayjs.default)(startDateTime);
-    const endDate = (0, _dayjs.default)(endDateTime);
+    const startDate = (0, import_dayjs.default)(startDateTime);
+    const endDate = (0, import_dayjs.default)(endDateTime);
     if (targetDate.isSameOrAfter(startDate) && targetDate.isSameOrBefore(endDate)) {
       return true;
     }
   }
   return false;
 };
-
-// 处理重复日程逻辑
-const isInRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule, startDate, endDate) => {
+var isInRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule, startDate, endDate) => {
   if (!schedule.repeat_rule) {
     return false;
   }
-  const {
-    repeat_rule,
-    repeat_type
-  } = schedule;
-  const targetDateOnly = (0, _dayjs.default)(targetDateString); // 只取日期部分
-
-  // 首先检查是否在包含日期中（包含日期是额外增加的有效日期）
+  const { repeat_rule, repeat_type } = schedule;
+  const targetDateOnly = (0, import_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, _dayjs.default)(includedDate.start);
-      const includeEndDate = (0, _dayjs.default)(includedDate.end);
-      if (targetDateOnly.isSameOrAfter(includeStartDate, 'day') && targetDateOnly.isSameOrBefore(includeEndDate, 'day')) {
-        // 在包含日期中，直接返回true，无需检查其他条件
+      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")) {
         return true;
       }
     }
   }
-
-  // 检查是否在排除日期中
   for (const excludedDate of repeat_rule.excluded_date) {
-    const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
-    const excludeEndDate = (0, _dayjs.default)(excludedDate.end);
-    // 检查目标日期是否在排除范围内（包含边界）
-    if (targetDateOnly.isSameOrAfter(excludeStartDate, 'day') && targetDateOnly.isSameOrBefore(excludeEndDate, 'day')) {
+    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")) {
       return false;
     }
   }
-
-  // 检查重复规则的结束条件
-  if (repeat_rule.end.type === 'date' && repeat_rule.end.end_date) {
-    const ruleEndDate = (0, _dayjs.default)(repeat_rule.end.end_date);
+  if (repeat_rule.end.type === "date" && repeat_rule.end.end_date) {
+    const ruleEndDate = (0, import_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;
-    // 不支持月和年重复
   }
 };
-
-// 每日重复逻辑
-const isInDailyRepeat = (targetDate, startDate, endDate, repeatRule) => {
-  const daysDiff = targetDate.diff(startDate, 'day');
+var 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;
 };
-
-// 每周重复逻辑
-const isInWeeklyRepeat = (targetDate, startDate, endDate, repeatRule) => {
-  const targetDayOfWeek = targetDate.day(); // 0=周日, 1=周一, ..., 6=周六
-
-  // 检查是否在指定的星期几内
+var isInWeeklyRepeat = (targetDate, startDate, endDate, repeatRule) => {
+  const targetDayOfWeek = targetDate.day();
   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;
 };
-
-// 处理 time-slots 类型的重复日程
-const isInTimeSlotsRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+var isInTimeSlotsRepeatingSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.repeat_rule || !schedule.start_time) {
     return false;
   }
-  const {
-    repeat_rule,
-    repeat_type
-  } = schedule;
-  const startDate = (0, _dayjs.default)(schedule.start_time);
-  const targetDateOnly = (0, _dayjs.default)(targetDateString);
-
-  // 检查包含日期
+  const { repeat_rule, repeat_type } = schedule;
+  const startDate = (0, import_dayjs.default)(schedule.start_time);
+  const targetDateOnly = (0, import_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, _dayjs.default)(includedDate.start);
-      const includeEndDate = (0, _dayjs.default)(includedDate.end);
-      if (targetDateOnly.isSameOrAfter(includeStartDate, 'day') && targetDateOnly.isSameOrBefore(includeEndDate, 'day')) {
-        // 在包含日期中，检查时间段
+      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")) {
         return checkTimeSlotsForDate(targetDate, targetDateString, schedule.time_slot);
       }
     }
   }
-
-  // 检查排除日期
   for (const excludedDate of repeat_rule.excluded_date) {
-    const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
-    const excludeEndDate = (0, _dayjs.default)(excludedDate.end);
-    if (targetDateOnly.isSameOrAfter(excludeStartDate, 'day') && targetDateOnly.isSameOrBefore(excludeEndDate, 'day')) {
+    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")) {
       return false;
     }
   }
-
-  // 检查重复规则的结束条件
-  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')) {
+  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")) {
       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;
 };
-
-// 检查目标时间是否在某个时间段内（使用目标日期 + time_slot 时间）
-const checkTimeSlotsForDate = (targetDate, targetDateString, timeSlots) => {
+var 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, _dayjs.default)(slotStart);
-    const slotEndDate = (0, _dayjs.default)(slotEnd);
+    const slotStartDate = (0, import_dayjs.default)(slotStart);
+    const slotEndDate = (0, import_dayjs.default)(slotEnd);
     if (targetDate.isSameOrAfter(slotStartDate) && targetDate.isSameOrBefore(slotEndDate)) {
       return true;
     }
   }
   return false;
 };
-
-// 检查日期是否满足每日重复规则（只检查日期，不检查时间）
-const isInDailyRepeatForDate = (targetDate, startDate, repeatRule) => {
-  const daysDiff = targetDate.diff(startDate, 'day');
+var isInDailyRepeatForDate = (targetDate, startDate, repeatRule) => {
+  const daysDiff = targetDate.diff(startDate, "day");
   if (daysDiff < 0) {
     return false;
   }
-
-  // 检查频率
   return daysDiff % repeatRule.frequency === 0;
 };
-
-// 检查日期是否满足每周重复规则（只检查日期，不检查时间）
-const isInWeeklyRepeatForDate = (targetDate, startDate, repeatRule) => {
-  const targetDayOfWeek = targetDate.day(); // 0=周日, 1=周一, ..., 6=周六
-
-  // 检查是否在指定的星期几内
+var isInWeeklyRepeatForDate = (targetDate, startDate, repeatRule) => {
+  const targetDayOfWeek = targetDate.day();
   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;
 };
-
-/**
- * 根据预约时间过滤优惠券列表
- * @param discountList 优惠券列表
- * @param bookingTime 预约时间 (格式: YYYY-MM-DD HH:mm:ss)
- * @returns 过滤后的优惠券列表
- */
-const filterDiscountListByBookingTime = (discountList, bookingTime) => {
+var filterDiscountListByBookingTime = (discountList, bookingTime) => {
   if (!bookingTime) {
     return discountList;
   }
-  return discountList.filter(discount => {
-    if (discount?.metadata?.validity_type === "custom_schedule_validity") {
-      return getDateIsInSchedule(bookingTime, discount.custom_schedule_snapshot?.data || []);
+  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) || []);
     }
     try {
       const isHasStart = !!discount.start_date && !!discount.start_time;
-      const startDate = (0, _dayjs.default)(`${discount.start_date} ${discount.start_time}`);
-      const bookingTimeDayjs = (0, _dayjs.default)(bookingTime);
-
-      // 判断预约时间是否在开始时间之后
+      const startDate = (0, import_dayjs.default)(`${discount.start_date} ${discount.start_time}`);
+      const bookingTimeDayjs = (0, import_dayjs.default)(bookingTime);
       const isAfterStart = isHasStart ? bookingTimeDayjs.isSameOrAfter(startDate) : true;
-
-      // 判断预约时间是否在过期时间之前（expire_time 为空时为长期有效）
-      const isBeforeExpire = discount.expire_time ? bookingTimeDayjs.isSameOrBefore((0, _dayjs.default)(discount.expire_time)) : true;
+      const isBeforeExpire = discount.expire_time ? bookingTimeDayjs.isSameOrBefore((0, import_dayjs.default)(discount.expire_time)) : true;
       return isAfterStart && isBeforeExpire;
     } catch (error) {
       return true;
     }
   });
 };
-/**
- * 判断是否是订单级别的固定金额折扣卡
- * @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 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 折扣卡
- * @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();
+var calculateOrderLevelDiscountAllocation = (discount, applicableProducts) => {
+  const result = /* @__PURE__ */ new Map();
   if (applicableProducts.length === 0) {
     return result;
   }
-
-  // 计算适用商品的总金额（数量 × 单价）
   const totalAmount = applicableProducts.reduce((acc, product) => {
-    return new _decimal.default(acc).plus(new _decimal.default(product.amount).mul(product.quantity)).toNumber();
+    return new import_decimal.default(acc).plus(new import_decimal.default(product.amount).mul(product.quantity)).toNumber();
   }, 0);
   if (totalAmount <= 0) {
     return result;
   }
-
-  // 固定减免金额
-  const fixedAmount = new _decimal.default(discount.par_value || 0).toNumber();
-
-  // 如果固定金额 >= 商品总金额，折扣最高为商品金额（免费）
+  const fixedAmount = new import_decimal.default(discount.par_value || 0).toNumber();
   const actualDiscountTotal = Math.min(fixedAmount, totalAmount);
-
-  // 计算每个商品的单价折扣金额
-  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();
+  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();
     result.set(product.productId, {
       discountAmount: discountAmountPerItem,
       // 单价折扣金额
-      difference: 0 // 默认差值为0
+      difference: 0
+      // 默认差值为0
     });
-
-    // 累加实际分配的总折扣金额（单价折扣 × 数量）
-    allocatedTotal = allocatedTotal.plus(new _decimal.default(discountAmountPerItem).mul(product.quantity));
+    allocatedTotal = allocatedTotal.plus(
+      new import_decimal.default(discountAmountPerItem).mul(product.quantity)
+    );
   });
-
-  // 🔥 计算总差值
-  // 总差值 = 固定金额 - 所有商品的 (单价折扣 × 数量) 之和
-  const totalDifference = new _decimal.default(actualDiscountTotal).minus(allocatedTotal).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+  const totalDifference = new import_decimal.default(actualDiscountTotal).minus(allocatedTotal).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
   if (totalDifference > 0) {
-    // 🔥 判断商品是否是真正的"数量为1"
-    // 主商品：quantity === 1
-    // 子商品：quantity === 1 且 parentQuantity === 1
-    const isSingleQuantity = product => {
-      if (product.parentQuantity !== undefined) {
-        // 子商品：需要同时满足自身数量为1且主商品数量为1
+    const isSingleQuantity = (product) => {
+      if (product.parentQuantity !== void 0) {
         return product.quantity === 1 && product.parentQuantity === 1;
       }
-      // 主商品：只需要自身数量为1
       return product.quantity === 1;
     };
-
-    // 🔥 筛选出数量为1的商品
     const singleQuantityProducts = applicableProducts.filter(isSingleQuantity);
     if (singleQuantityProducts.length > 0) {
-      // 🔥 优先级1：找到有足够剩余空间且金额最大的商品
-      // 剩余空间 = 商品价格 - 当前折扣金额 >= 差值
-      const productsWithEnoughSpace = singleQuantityProducts.filter(product => {
+      const productsWithEnoughSpace = singleQuantityProducts.filter((product) => {
         const allocation = result.get(product.productId);
-        if (!allocation) return false;
-        const remainingSpace = new _decimal.default(product.amount).minus(allocation.discountAmount).toNumber();
+        if (!allocation)
+          return false;
+        const remainingSpace = new import_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 _decimal.default(targetAllocation.discountAmount).plus(totalDifference).toNumber(),
-            difference: 0 // 不需要存储差值
+            discountAmount: new import_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);
@@ -526,8 +379,6 @@ const calculateOrderLevelDiscountAllocation = (discount, applicableProducts) =>
         }
       }
     } else {
-      // 🔥 优先级3：没有数量为1的商品，走原有逻辑
-      // 差值存储在最后一个商品的metadata中
       const lastProduct = applicableProducts[applicableProducts.length - 1];
       const lastProductAllocation = result.get(lastProduct.productId);
       if (lastProductAllocation) {
@@ -540,4 +391,16 @@ const calculateOrderLevelDiscountAllocation = (discount, applicableProducts) =>
   }
   return result;
 };
-exports.calculateOrderLevelDiscountAllocation = calculateOrderLevelDiscountAllocation;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateOrderLevelDiscountAllocation,
+  filterDiscountListByBookingTime,
+  getDateIsInSchedule,
+  getDiscountAmount,
+  getDiscountListAmount,
+  getDiscountListAmountTotal,
+  isAllNormalProduct,
+  isNormalProductByDurationSchedule,
+  isOrderLevelFixedAmountDiscount,
+  uniqueById
+});