@pisell/pisellos 2.1.85 → 2.1.87

package/lib/modules/Rules/types.d.ts

@@ -31,7 +31,6 @@ export interface RulesModuleAPI {
         holders: {
             form_record_id: number;
         }[];
-        orderTotalAmount: number;
         isFormSubject: boolean;
     }) => DiscountResult;
 }

package/lib/modules/Schedule/getDateIsInSchedule.d.ts

@@ -0,0 +1,32 @@
+import dayjs from "dayjs";
+import { ScheduleItem } from "./types";
+export declare const getDateIsInSchedule: (dateTime: string, scheduleList: ScheduleItem[]) => boolean;
+export type ScheduleTimeSlot = {
+    /** 开始时间 HH:mm */
+    start_time: string;
+    /** 结束时间 HH:mm */
+    end_time: string;
+    /** 开始日期时间 YYYY-MM-DD HH:mm:ss */
+    start_at: dayjs.Dayjs;
+    /** 结束日期时间 YYYY-MM-DD HH:mm:ss */
+    end_at: dayjs.Dayjs;
+};
+/**
+ * 获取当前日期日程时间点
+ * @param date 日期 YYYY-MM-DD
+ * @param scheduleList 日程列表
+ * @returns 当前日期日程时间点 结构，数组 [{
+ *
+ *  // HH:mm
+ *  end_time: string,
+ *  // HH:mm
+ *  start_time: string,
+ *  // 日期时间
+ *  // YYYY-MM-DD HH:mm:ss
+ *  end_at: Dayjs,
+ *  // YYYY-MM-DD HH:mm:ss
+ *  start_at: Dayjs,
+ *
+ * }]
+ */
+export declare const getScheduleStartEndTimePoints: (date: string, scheduleList: ScheduleItem[]) => ScheduleTimeSlot[];

package/lib/modules/Schedule/getDateIsInSchedule.js

@@ -0,0 +1,451 @@
+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/modules/Schedule/getDateIsInSchedule.ts
+var getDateIsInSchedule_exports = {};
+__export(getDateIsInSchedule_exports, {
+  getDateIsInSchedule: () => getDateIsInSchedule,
+  getScheduleStartEndTimePoints: () => getScheduleStartEndTimePoints
+});
+module.exports = __toCommonJS(getDateIsInSchedule_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var getDateIsInSchedule = (dateTime, scheduleList) => {
+  if (!dateTime || !scheduleList || scheduleList.length === 0) {
+    return false;
+  }
+  const targetDate = (0, import_dayjs.default)(dateTime);
+  if (!targetDate.isValid()) {
+    return false;
+  }
+  for (const schedule of scheduleList) {
+    if (isTimeInScheduleItem(dateTime, schedule)) {
+      return true;
+    }
+  }
+  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";
+  switch (schedule.type) {
+    case "standard":
+      return isInStandardSchedule(targetDate, targetDateString, targetTimeString, schedule);
+    case "time-slots":
+      return isInTimeSlotsSchedule(targetDate, targetDateString, targetTimeString, schedule);
+    case "designation":
+      return isInDesignationSchedule(targetDate, targetDateString, targetTimeString, schedule);
+    default:
+      return false;
+  }
+};
+var 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 isInBasicRange = targetDate.isSameOrAfter(startDate) && targetDate.isSameOrBefore(endDate);
+  if (schedule.repeat_type === "none") {
+    return isInBasicRange;
+  }
+  return isInRepeatingSchedule(targetDate, targetDateString, targetTimeString, schedule, startDate, endDate);
+};
+var isInTimeSlotsSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+  if (!schedule.start_time) {
+    return false;
+  }
+  const scheduleDate = schedule.start_time.split(" ")[0];
+  if (targetDateString !== scheduleDate) {
+    return false;
+  }
+  for (const timeSlot of schedule.time_slot) {
+    const slotStart = `${scheduleDate} ${timeSlot.start_time}:00`;
+    const slotEnd = `${scheduleDate} ${timeSlot.end_time}:00`;
+    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;
+};
+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, import_dayjs.default)(startDateTime);
+    const endDate = (0, import_dayjs.default)(endDateTime);
+    if (targetDate.isSameOrAfter(startDate) && targetDate.isSameOrBefore(endDate)) {
+      return true;
+    }
+  }
+  return false;
+};
+var 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);
+  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")) {
+        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")) {
+      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 (targetDate.isAfter(ruleEndDate)) {
+      return false;
+    }
+  }
+  switch (repeat_type) {
+    case "daily":
+      return isInDailyRepeat(targetDate, startDate, endDate, repeat_rule);
+    case "weekly":
+      return isInWeeklyRepeat(targetDate, startDate, endDate, repeat_rule);
+    default:
+      return false;
+  }
+};
+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();
+  return targetTimeOfDay >= startTimeOfDay && targetTimeOfDay <= endTimeOfDay;
+};
+var isInWeeklyRepeat = (targetDate, startDate, endDate, repeatRule) => {
+  const targetDayOfWeek = targetDate.day();
+  if (!repeatRule.frequency_date.includes(targetDayOfWeek)) {
+    return false;
+  }
+  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 getScheduleStartEndTimePoints = (date, scheduleList) => {
+  if (!date || !scheduleList || scheduleList.length === 0) {
+    return [];
+  }
+  const targetDate = (0, import_dayjs.default)(date);
+  if (!targetDate.isValid()) {
+    return [];
+  }
+  const timeSlots = [];
+  for (const schedule of scheduleList) {
+    const slots = extractTimeSlotsFromSchedule(date, schedule);
+    timeSlots.push(...slots);
+  }
+  return mergeAndSortTimeSlots(timeSlots);
+};
+var extractTimeSlotsFromSchedule = (date, schedule) => {
+  switch (schedule.type) {
+    case "standard":
+      return extractStandardScheduleTimeSlots(date, schedule);
+    case "time-slots":
+      return extractTimeSlotsScheduleTimeSlots(date, schedule);
+    case "designation":
+      return extractDesignationScheduleTimeSlots(date, schedule);
+    default:
+      return [];
+  }
+};
+var extractStandardScheduleTimeSlots = (date, schedule) => {
+  if (!schedule.start_time || !schedule.end_time) {
+    return [];
+  }
+  const targetDate = (0, import_dayjs.default)(date);
+  const startDate = (0, import_dayjs.default)(schedule.start_time);
+  const endDate = (0, import_dayjs.default)(schedule.end_time);
+  if (!isDateInStandardSchedule(targetDate, schedule, startDate, endDate)) {
+    return [];
+  }
+  const startTime = startDate.format("HH:mm");
+  const endTime = endDate.format("HH:mm");
+  const startAt = (0, import_dayjs.default)(`${date} ${startTime}:00`);
+  const endAt = (0, import_dayjs.default)(`${date} ${endTime}:00`);
+  return [{
+    start_time: startTime,
+    end_time: endTime,
+    start_at: startAt,
+    end_at: endAt
+  }];
+};
+var extractTimeSlotsScheduleTimeSlots = (date, schedule) => {
+  if (!schedule.start_time || !schedule.time_slot || schedule.time_slot.length === 0) {
+    return [];
+  }
+  const targetDate = (0, import_dayjs.default)(date);
+  const scheduleStartDate = (0, import_dayjs.default)(schedule.start_time.split(" ")[0]);
+  if (!isDateInTimeSlotsSchedule(targetDate, schedule, scheduleStartDate)) {
+    return [];
+  }
+  const slots = [];
+  for (const timeSlot of schedule.time_slot) {
+    if (!timeSlot.start_time || !timeSlot.end_time) {
+      continue;
+    }
+    const startAt = (0, import_dayjs.default)(`${date} ${timeSlot.start_time}:00`);
+    const endAt = (0, import_dayjs.default)(`${date} ${timeSlot.end_time}:00`);
+    slots.push({
+      start_time: timeSlot.start_time,
+      end_time: timeSlot.end_time,
+      start_at: startAt,
+      end_at: endAt
+    });
+  }
+  return slots;
+};
+var isDateInTimeSlotsSchedule = (targetDate, schedule, scheduleStartDate) => {
+  if (schedule.repeat_type === "none") {
+    return targetDate.isSame(scheduleStartDate, "day");
+  }
+  if (!schedule.repeat_rule) {
+    return false;
+  }
+  const { repeat_rule, repeat_type } = schedule;
+  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 (targetDate.isSameOrAfter(includeStartDate, "day") && targetDate.isSameOrBefore(includeEndDate, "day")) {
+        return true;
+      }
+    }
+  }
+  if (repeat_rule.excluded_date && repeat_rule.excluded_date.length > 0) {
+    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 (targetDate.isSameOrAfter(excludeStartDate, "day") && targetDate.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 (targetDate.isAfter(ruleEndDate, "day")) {
+      return false;
+    }
+  }
+  if (targetDate.isBefore(scheduleStartDate, "day")) {
+    return false;
+  }
+  switch (repeat_type) {
+    case "daily":
+      return isDateInDailyRepeat(targetDate, scheduleStartDate, repeat_rule);
+    case "weekly":
+      return isDateInWeeklyRepeat(targetDate, scheduleStartDate, repeat_rule);
+    default:
+      return false;
+  }
+};
+var extractDesignationScheduleTimeSlots = (date, schedule) => {
+  if (!schedule.designation) {
+    return [];
+  }
+  const targetDate = (0, import_dayjs.default)(date);
+  const designations = Array.isArray(schedule.designation) ? schedule.designation : [schedule.designation];
+  const slots = [];
+  for (const designation of designations) {
+    const startDate = (0, import_dayjs.default)(designation.start_date);
+    const endDate = (0, import_dayjs.default)(designation.end_date);
+    if (isDateInDesignationSchedule(targetDate, schedule, designation, startDate, endDate)) {
+      const startAt = (0, import_dayjs.default)(`${date} ${designation.start_time}:00`);
+      const endAt = (0, import_dayjs.default)(`${date} ${designation.end_time}:00`);
+      slots.push({
+        start_time: designation.start_time,
+        end_time: designation.end_time,
+        start_at: startAt,
+        end_at: endAt
+      });
+    }
+  }
+  return slots;
+};
+var isDateInDesignationSchedule = (targetDate, schedule, designation, startDate, endDate) => {
+  if (schedule.repeat_type === "none") {
+    return targetDate.isSameOrAfter(startDate, "day") && targetDate.isSameOrBefore(endDate, "day");
+  }
+  if (!schedule.repeat_rule) {
+    return false;
+  }
+  const { repeat_rule, repeat_type } = schedule;
+  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 (targetDate.isSameOrAfter(includeStartDate, "day") && targetDate.isSameOrBefore(includeEndDate, "day")) {
+        return true;
+      }
+    }
+  }
+  if (repeat_rule.excluded_date && repeat_rule.excluded_date.length > 0) {
+    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 (targetDate.isSameOrAfter(excludeStartDate, "day") && targetDate.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 (targetDate.isAfter(ruleEndDate, "day")) {
+      return false;
+    }
+  }
+  if (!targetDate.isSameOrAfter(startDate, "day") || !targetDate.isSameOrBefore(endDate, "day")) {
+    if (targetDate.isBefore(startDate, "day")) {
+      return false;
+    }
+  }
+  switch (repeat_type) {
+    case "daily":
+      return isDateInDailyRepeat(targetDate, startDate, repeat_rule);
+    case "weekly":
+      return isDateInWeeklyRepeat(targetDate, startDate, repeat_rule);
+    default:
+      return false;
+  }
+};
+var isDateInStandardSchedule = (targetDate, schedule, startDate, endDate) => {
+  const targetDateString = targetDate.format("YYYY-MM-DD");
+  if (schedule.repeat_type === "none") {
+    const scheduleStartDate = startDate.format("YYYY-MM-DD");
+    const scheduleEndDate = endDate.format("YYYY-MM-DD");
+    return targetDate.isSameOrAfter(scheduleStartDate, "day") && targetDate.isSameOrBefore(scheduleEndDate, "day");
+  }
+  if (!schedule.repeat_rule) {
+    return false;
+  }
+  const { repeat_rule, repeat_type } = schedule;
+  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 (targetDate.isSameOrAfter(includeStartDate, "day") && targetDate.isSameOrBefore(includeEndDate, "day")) {
+        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 (targetDate.isSameOrAfter(excludeStartDate, "day") && targetDate.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 (targetDate.isAfter(ruleEndDate, "day")) {
+      return false;
+    }
+  }
+  if (targetDate.isBefore(startDate, "day")) {
+    return false;
+  }
+  switch (repeat_type) {
+    case "daily":
+      return isDateInDailyRepeat(targetDate, startDate, repeat_rule);
+    case "weekly":
+      return isDateInWeeklyRepeat(targetDate, startDate, repeat_rule);
+    default:
+      return false;
+  }
+};
+var isDateInDailyRepeat = (targetDate, startDate, repeatRule) => {
+  const daysDiff = targetDate.diff(startDate, "day");
+  if (daysDiff < 0) {
+    return false;
+  }
+  return daysDiff % repeatRule.frequency === 0;
+};
+var isDateInWeeklyRepeat = (targetDate, startDate, repeatRule) => {
+  const targetDayOfWeek = targetDate.day();
+  if (!repeatRule.frequency_date.includes(targetDayOfWeek)) {
+    return false;
+  }
+  const weeksDiff = targetDate.diff(startDate, "week");
+  if (weeksDiff < 0) {
+    return false;
+  }
+  return weeksDiff % repeatRule.frequency === 0;
+};
+var mergeAndSortTimeSlots = (slots) => {
+  if (slots.length === 0) {
+    return [];
+  }
+  const sorted = [...slots].sort((a, b) => {
+    return a.start_at.valueOf() - b.start_at.valueOf();
+  });
+  const unique = [];
+  const seenKeys = /* @__PURE__ */ new Set();
+  for (const slot of sorted) {
+    const key = `${slot.start_time}-${slot.end_time}`;
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      unique.push(slot);
+    }
+  }
+  return unique;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDateIsInSchedule,
+  getScheduleStartEndTimePoints
+});

package/lib/modules/Schedule/index.d.ts

@@ -33,5 +33,5 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     static isInScheduleByDate({ date, schedule, }: {
         date: string;
         schedule: any;
-    }): boolean | undefined;
+    }): boolean;
 }

package/lib/modules/Schedule/index.js

@@ -39,6 +39,7 @@ var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"));
 var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
 var import_utils = require("../Date/utils");
 var import_utils2 = require("./utils");
+var import_getDateIsInSchedule = require("./getDateIsInSchedule");
 import_dayjs.default.extend(import_isSameOrBefore.default);
 import_dayjs.default.extend(import_isSameOrAfter.default);
 var ScheduleModule = class extends import_BaseModule.BaseModule {
@@ -169,6 +170,7 @@ var ScheduleModule = class extends import_BaseModule.BaseModule {
     schedule
   }) {
     var _a, _b, _c, _d;
+    return (0, import_getDateIsInSchedule.getDateIsInSchedule)(date, [schedule]);
     if (schedule.start_time && schedule.end_time) {
       const isBeforeStartTime = (0, import_dayjs.default)(date).isBefore(
         (0, import_dayjs.default)(schedule.start_time)

package/lib/modules/Summary/index.js

@@ -65,7 +65,7 @@ var SummaryModule = class extends import_BaseModule.BaseModule {
     this.getSurchargeList();
   }
   async getSurchargeList() {
-    const surchargeList = await this.request.get("/order/custom-surcharge/available", {
+    const surchargeList = await this.request.get("/order/custom-surcharge/available/v2", {
       channel: "online-store",
       is_assemble_product_data: 1,
       is_assemble_schedule_data: 1,
@@ -74,14 +74,18 @@ var SummaryModule = class extends import_BaseModule.BaseModule {
     this.store.surchargeList = (surchargeList == null ? void 0 : surchargeList.data) || [];
   }
   async getSummary(cartItems) {
-    var _a, _b;
+    var _a, _b, _c;
     const shopInfo = ((_b = (_a = this.shopStore.get("core")) == null ? void 0 : _a.core) == null ? void 0 : _b.shop) || {};
-    const summary = (0, import_utils.calculatePriceDetails)(
-      shopInfo,
-      cartItems,
-      import_Schedule.ScheduleModule.isInScheduleByDate,
-      this.store.surchargeList
-    );
+    const scheduleModule = this.core.getModule("appointmentBooking_schedule");
+    const needScheduleIds = this.store.surchargeList.map((item) => item.available_schedule_ids).flat();
+    const scheduleList = scheduleModule == null ? void 0 : scheduleModule.getScheduleListByIds(needScheduleIds);
+    const scheduleById = {};
+    if (Array.isArray(scheduleList)) {
+      for (let item of scheduleList) {
+        scheduleById[item.id] = item;
+      }
+    }
+    const summary = (0, import_utils.calculatePriceDetails)(shopInfo, cartItems, (_c = import_Schedule.ScheduleModule) == null ? void 0 : _c.isInScheduleByDate, this.store.surchargeList, scheduleById);
     this.store.summary = summary;
     return this.store.summary;
   }
@@ -115,7 +119,16 @@ var SummaryModule = class extends import_BaseModule.BaseModule {
     });
   }
   getSurchargeforUtils(items) {
-    const surchargeList = (0, import_utils.getSurcharge)({ service: items, addons: [], bookingDetail: null, bookingId: void 0 }, { isEdit: false, isInScheduleByDate: import_Schedule.ScheduleModule.isInScheduleByDate, surcharge_list: this.store.surchargeList, scheduleById: {} });
+    const scheduleModule = this.core.getModule("appointmentBooking_schedule");
+    const needScheduleIds = this.store.surchargeList.map((item) => item.available_schedule_ids).flat();
+    const scheduleList = scheduleModule == null ? void 0 : scheduleModule.getScheduleListByIds(needScheduleIds);
+    const scheduleById = {};
+    if (Array.isArray(scheduleList)) {
+      for (let item of scheduleList) {
+        scheduleById[item.id] = item;
+      }
+    }
+    const surchargeList = (0, import_utils.getSurcharge)({ service: items, addons: [], bookingDetail: null, bookingId: void 0 }, { isEdit: false, isInScheduleByDate: import_Schedule.ScheduleModule.isInScheduleByDate, surcharge_list: this.store.surchargeList, scheduleById });
     const surchargeAmount = new import_decimal.default((0, import_utils.getSurchargeAmount)({ bookingDetail: null, bookingId: void 0 }, surchargeList, { isEdit: false }));
     return {
       surchargeList,

package/lib/modules/Summary/types.d.ts

@@ -6,8 +6,6 @@ export interface ISummaryState {
         subtotal: string | number;
         /** 最终总价 */
         total: string | number;
-        /** 最终原始价格 不包含折扣卡商品券折扣 */
-        originTotal: string | number;
         /** 税率标题 */
         taxTitle?: string;
         /** 商品总费率 */

package/lib/modules/Summary/utils.d.ts

@@ -1,7 +1,7 @@
 import Decimal from 'decimal.js';
 import { CartItem } from '../Cart/types';
 import { ISummaryState } from './types';
-export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[], isInScheduleByDate: any, surchargeList: any[]) => ISummaryState['summary'];
+export declare const calculatePriceDetails: (shopInfo: any, items: CartItem[], isInScheduleByDate: any, surchargeList: any[], scheduleById: Record<string, any>) => ISummaryState['summary'];
 /**
  * 获取子商品折扣信息
  * @param item
@@ -58,12 +58,6 @@ export declare const getTax: ({ service, addons, bookingDetail, bookingId }: {
  * @returns 商品总价字符串，保留2位小数
  */
 export declare const calculateSubtotal: (items: CartItem[]) => string;
-/**
- * 计算商品小计（不含其他费用 不包含折扣卡商品券抵扣金额）
- * @param items - 购物车商品数组
- * @returns 商品总价字符串，保留2位小数
- */
-export declare const calculateOriginSubtotal: (items: CartItem[]) => string;
 /**
  * @title: 单个商品的税费
  * @description: