@pisell/pisellos 0.0.567 → 0.0.568

package/lib/modules/Schedule/getDateIsInSchedule.js

@@ -1,51 +1,27 @@
-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
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(getDateIsInSchedule_exports);
-var import_dayjs = __toESM(require("dayjs"));
-var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
-var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"));
-import_dayjs.default.extend(import_isSameOrAfter.default);
-import_dayjs.default.extend(import_isSameOrBefore.default);
-var getDateIsInSchedule = (dateTime, scheduleList) => {
+exports.getScheduleStartEndTimePoints = exports.getDateIsInSchedule = void 0;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _isSameOrAfter = _interopRequireDefault(require("dayjs/plugin/isSameOrAfter"));
+var _isSameOrBefore = _interopRequireDefault(require("dayjs/plugin/isSameOrBefore"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+_dayjs.default.extend(_isSameOrAfter.default);
+_dayjs.default.extend(_isSameOrBefore.default);
+
+// 获取时间是否在日程范围内
+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;
@@ -53,173 +29,263 @@ 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);
+
+  // 先检查是否在基础时间范围内（不考虑重复），end 为开区间
   const isInBasicRange = targetDate.isSameOrAfter(startDate) && targetDate.isBefore(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;
   }
-  const scheduleStartDate = (0, import_dayjs.default)(schedule.start_time.split(" ")[0]);
+  const scheduleStartDate = (0, _dayjs.default)(schedule.start_time.split(' ')[0]);
   if (!isDateInTimeSlotsSchedule(targetDate, schedule, scheduleStartDate)) {
     return false;
   }
   for (const timeSlot of schedule.time_slot) {
-    const slotStart = (0, import_dayjs.default)(`${targetDateString} ${timeSlot.start_time}:00`);
-    const slotEnd = (0, import_dayjs.default)(`${targetDateString} ${timeSlot.end_time}:00`);
+    const slotStart = (0, _dayjs.default)(`${targetDateString} ${timeSlot.start_time}:00`);
+    const slotEnd = (0, _dayjs.default)(`${targetDateString} ${timeSlot.end_time}:00`);
     if (targetDate.isSameOrAfter(slotStart) && targetDate.isBefore(slotEnd)) {
       return true;
     }
   }
   return false;
 };
-var isInDesignationSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
+
+// 处理指定类型日程
+const isInDesignationSchedule = (targetDate, targetDateString, targetTimeString, schedule) => {
   if (!schedule.designation) {
     return false;
   }
+
+  // @ts-ignore
   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.isBefore(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();
+
+  // 每日重复：每天都在相同的时间段内有效 [start, end)
   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 getScheduleStartEndTimePoints = (date, scheduleList) => {
+
+// 日程时间段类型
+
+/**
+ * 获取当前日期日程时间点
+ * @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,
+ * 
+ * }]
+ */
+const getScheduleStartEndTimePoints = (date, scheduleList) => {
   if (!date || !scheduleList || scheduleList.length === 0) {
     return [];
   }
-  const targetDate = (0, import_dayjs.default)(date);
+  const targetDate = (0, _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) => {
+
+/**
+ * 从单个日程中提取指定日期的时间段
+ */
+exports.getScheduleStartEndTimePoints = getScheduleStartEndTimePoints;
+const extractTimeSlotsFromSchedule = (date, schedule) => {
   switch (schedule.type) {
-    case "standard":
+    case 'standard':
       return extractStandardScheduleTimeSlots(date, schedule);
-    case "time-slots":
+    case 'time-slots':
       return extractTimeSlotsScheduleTimeSlots(date, schedule);
-    case "designation":
+    case 'designation':
       return extractDesignationScheduleTimeSlots(date, schedule);
     default:
       return [];
   }
 };
-var extractStandardScheduleTimeSlots = (date, schedule) => {
+
+/**
+ * 提取标准类型日程的时间段
+ */
+const 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);
+  const targetDate = (0, _dayjs.default)(date);
+  const startDate = (0, _dayjs.default)(schedule.start_time);
+  const endDate = (0, _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`);
+
+  // 提取时间部分
+  const startTime = startDate.format('HH:mm');
+  const endTime = endDate.format('HH:mm');
+
+  // 构造完整的日期时间
+  const startAt = (0, _dayjs.default)(`${date} ${startTime}:00`);
+  const endAt = (0, _dayjs.default)(`${date} ${endTime}:00`);
   return [{
     start_time: startTime,
     end_time: endTime,
@@ -227,22 +293,30 @@ var extractStandardScheduleTimeSlots = (date, schedule) => {
     end_at: endAt
   }];
 };
-var extractTimeSlotsScheduleTimeSlots = (date, schedule) => {
+
+/**
+ * 提取时间段类型日程的时间段
+ */
+const 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]);
+  const targetDate = (0, _dayjs.default)(date);
+  const scheduleStartDate = (0, _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`);
+    const startAt = (0, _dayjs.default)(`${date} ${timeSlot.start_time}:00`);
+    const endAt = (0, _dayjs.default)(`${date} ${timeSlot.end_time}:00`);
     slots.push({
       start_time: timeSlot.start_time,
       end_time: timeSlot.end_time,
@@ -252,63 +326,90 @@ var extractTimeSlotsScheduleTimeSlots = (date, schedule) => {
   }
   return slots;
 };
-var isDateInTimeSlotsSchedule = (targetDate, schedule, scheduleStartDate) => {
-  if (schedule.repeat_type === "none") {
-    return targetDate.isSame(scheduleStartDate, "day");
+
+/**
+ * 检查日期是否在时间段类型日程范围内
+ */
+const isDateInTimeSlotsSchedule = (targetDate, schedule, scheduleStartDate) => {
+  // 不重复的日程
+  if (schedule.repeat_type === 'none') {
+    // 只在 start_time 的日期有效
+    return targetDate.isSame(scheduleStartDate, 'day');
   }
+
+  // 重复的日程，需要检查重复规则
   if (!schedule.repeat_rule) {
     return false;
   }
-  const { repeat_rule, repeat_type } = schedule;
+  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")) {
+      const includeStartDate = (0, _dayjs.default)(includedDate.start);
+      const includeEndDate = (0, _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")) {
+      const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
+      const excludeEndDate = (0, _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")) {
+
+  // 检查重复规则的结束条件
+  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, 'day')) {
       return false;
     }
   }
-  if (targetDate.isBefore(scheduleStartDate, "day")) {
+
+  // 检查是否在开始日期之前
+  if (targetDate.isBefore(scheduleStartDate, 'day')) {
     return false;
   }
+
+  // 根据重复类型检查
   switch (repeat_type) {
-    case "daily":
+    case 'daily':
       return isDateInDailyRepeat(targetDate, scheduleStartDate, repeat_rule);
-    case "weekly":
+    case 'weekly':
       return isDateInWeeklyRepeat(targetDate, scheduleStartDate, repeat_rule);
     default:
       return false;
   }
 };
-var extractDesignationScheduleTimeSlots = (date, schedule) => {
+
+/**
+ * 提取指定日期类型日程的时间段
+ */
+const extractDesignationScheduleTimeSlots = (date, schedule) => {
   if (!schedule.designation) {
     return [];
   }
-  const targetDate = (0, import_dayjs.default)(date);
+  const targetDate = (0, _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);
+    const startDate = (0, _dayjs.default)(designation.start_date);
+    const endDate = (0, _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`);
+      const startAt = (0, _dayjs.default)(`${date} ${designation.start_time}:00`);
+      const endAt = (0, _dayjs.default)(`${date} ${designation.end_time}:00`);
       slots.push({
         start_time: designation.start_time,
         end_time: designation.end_time,
@@ -319,125 +420,196 @@ var extractDesignationScheduleTimeSlots = (date, schedule) => {
   }
   return slots;
 };
-var isDateInDesignationSchedule = (targetDate, schedule, designation, startDate, endDate) => {
-  if (schedule.repeat_type === "none") {
-    return targetDate.isSameOrAfter(startDate, "day") && targetDate.isSameOrBefore(endDate, "day");
+
+/**
+ * 检查日期是否在指定日期类型日程范围内
+ */
+const 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;
+  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")) {
+      const includeStartDate = (0, _dayjs.default)(includedDate.start);
+      const includeEndDate = (0, _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")) {
+      const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
+      const excludeEndDate = (0, _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")) {
+
+  // 检查重复规则的结束条件
+  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, 'day')) {
       return false;
     }
   }
-  if (!targetDate.isSameOrAfter(startDate, "day") || !targetDate.isSameOrBefore(endDate, "day")) {
-    if (targetDate.isBefore(startDate, "day")) {
+
+  // 检查是否在基本日期范围内
+  if (!targetDate.isSameOrAfter(startDate, 'day') || !targetDate.isSameOrBefore(endDate, 'day')) {
+    // 对于重复日程，如果不在基本范围内，还需要检查是否符合重复规则
+    // 只要在 startDate 之后，并且符合重复规则即可
+    if (targetDate.isBefore(startDate, 'day')) {
       return false;
     }
   }
+
+  // 根据重复类型检查
   switch (repeat_type) {
-    case "daily":
+    case 'daily':
       return isDateInDailyRepeat(targetDate, startDate, repeat_rule);
-    case "weekly":
+    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");
+
+/**
+ * 检查日期是否在标准日程范围内
+ */
+const 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;
+  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")) {
+      const includeStartDate = (0, _dayjs.default)(includedDate.start);
+      const includeEndDate = (0, _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")) {
+    const excludeStartDate = (0, _dayjs.default)(excludedDate.start);
+    const excludeEndDate = (0, _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")) {
+
+  // 检查重复规则的结束条件
+  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, 'day')) {
       return false;
     }
   }
-  if (targetDate.isBefore(startDate, "day")) {
+
+  // 检查是否在开始日期之前
+  if (targetDate.isBefore(startDate, 'day')) {
     return false;
   }
+
+  // 根据重复类型检查
   switch (repeat_type) {
-    case "daily":
+    case 'daily':
       return isDateInDailyRepeat(targetDate, startDate, repeat_rule);
-    case "weekly":
+    case 'weekly':
       return isDateInWeeklyRepeat(targetDate, startDate, repeat_rule);
     default:
       return false;
   }
 };
-var isDateInDailyRepeat = (targetDate, startDate, repeatRule) => {
-  const daysDiff = targetDate.diff(startDate, "day");
+
+/**
+ * 检查日期是否符合每日重复规则
+ */
+const 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();
+
+/**
+ * 检查日期是否符合每周重复规则
+ */
+const isDateInWeeklyRepeat = (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 mergeAndSortTimeSlots = (slots) => {
+
+/**
+ * 对时间段去重并排序
+ * 只移除开始时间和结束时间完全相同的重复时间段
+ */
+const 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();
+  const seenKeys = new Set();
   for (const slot of sorted) {
+    // 使用开始时间和结束时间作为唯一键
     const key = `${slot.start_time}-${slot.end_time}`;
     if (!seenKeys.has(key)) {
       seenKeys.add(key);
@@ -445,9 +617,4 @@ var mergeAndSortTimeSlots = (slots) => {
     }
   }
   return unique;
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getDateIsInSchedule,
-  getScheduleStartEndTimePoints
-});
+};