misp-ui-library-test 0.0.1

package/src/utils/moment/index.js

@@ -0,0 +1,909 @@
+/**
+ * @file 日期时间工具库 - 基于原生 JavaScript 实现
+ * @description 提供日期格式化、解析、修改、比较等核心方法，满足时间选择器组件需求
+ * @module @vue2-ui/utils/moment
+ */
+
+/* -------------------------------------------------------------------------- */
+/*                                 日期格式化                                 */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * 将 Date 对象格式化为指定格式的字符串
+ * 
+ * 支持的格式令牌：
+ * - 年: [YYYY]
+ * - 月: [MM]
+ * - 日: [dd]
+ * - 时: [HH]
+ * - 分: [mm]
+ * - 秒: [ss]
+ * - 上午/下午: [A]
+ *
+ * @param {Date} date - 需要格式化的日期对象
+ * @param {string} format - 格式化模板，例如 'yyyy-MM-dd HH:mm:ss'
+ * @returns {string} 格式化后的日期字符串，如果日期无效则返回空字符串 ''
+ * 
+ * @example
+ * const date = new Date(2023, 9, 5, 14, 30, 0);
+ * formatDate(date, 'yyyy-MM-dd'); // '2023-10-05'
+ * formatDate(date, 'HH:mm:ss');   // '14:30:00'
+ * formatDate(date, 'yyyy年MM月dd日'); // '2023年10月05日'
+ */
+export function formatDate(date, format) {
+  if (!(date instanceof Date) || isNaN(date.getTime())) return ''
+
+  const year = date.getFullYear()
+  const month = date.getMonth()
+  const day = date.getDate()
+  const hours = date.getHours()
+  const minutes = date.getMinutes()
+  const seconds = date.getSeconds()
+  const milliseconds = date.getMilliseconds() // 新增：获取毫秒
+
+  const pad2 = (n) => String(n).padStart(2, '0')
+  const pad3 = (n) => String(n).padStart(3, '0') // 新增：毫秒补零辅助函数
+
+  const tokenFn = {
+    YYYY: () => String(year),
+    yyyy: () => String(year),
+    yyy: () => pad2(year).slice(-3),
+    YY: () => pad2(year % 100),
+    yy: () => pad2(year % 100),
+    y: () => String(year),
+    MMMM: () => ['', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'][month + 1],
+    MMM: () => ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][month + 1],
+    MM: () => pad2(month + 1),
+    M: () => String(month + 1),
+    dd: () => pad2(day),
+    DD: () => pad2(day),
+    d: () => String(day),
+    HH: () => pad2(hours),
+    H: () => String(hours),
+    hh: () => pad2(hours % 12 === 0 ? 12 : hours % 12),
+    h: () => String(hours % 12 === 0 ? 12 : hours % 12),
+    mm: () => pad2(minutes),
+    m: () => String(minutes),
+    ss: () => pad2(seconds),
+    s: () => String(seconds),
+    SSS: () => pad3(milliseconds), // 新增：毫秒格式化
+    A: () => (hours < 12 ? 'AM' : 'PM'),
+    a: () => (hours < 12 ? 'am' : 'pm'),
+  }
+
+  // 新增：将 SSS 加入排序列表，确保它比可能的其他短令牌优先匹配（虽然目前没有其他S开头的冲突）
+  const tokenOrder = ['YYYY', 'yyyy', 'yyy', 'YY', 'yy', 'MMMM', 'MMM', 'MM', 'M', 'dd', 'DD', 'd', 'HH', 'H', 'hh', 'h', 'mm', 'm', 'ss', 's', 'SSS', 'A', 'a', 'y']
+  const ordered = tokenOrder.sort((a, b) => b.length - a.length)
+
+  let result = format
+  for (const token of ordered) {
+    if (result.includes(token) && tokenFn[token]) {
+      result = result.split(token).join(tokenFn[token]())
+    }
+  }
+
+  return result
+}
+
+/* -------------------------------------------------------------------------- */
+/*                                 日期解析                                   */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * 从格式化的字符串中解析出 Date 对象
+ * 
+ * 支持逆向解析 [formatDate] 中定义的格式令牌。
+ * 缺失的部分将使用默认值：
+ * - 年: 当前年份
+ * - 月: 0 (一月)
+ * - 日: 1
+ * - 时/分/秒: 0
+ *
+ * @param {string} string - 日期字符串，例如 '2023-10-05'
+ * @param {string} format - 对应的格式化模板，例如 'yyyy-MM-dd'
+ * @returns {Date|null} 解析后的日期对象，如果解析失败或输入无效则返回 null
+ * 
+ * @example
+ * parseDate('2023-10-05', 'yyyy-MM-dd'); // Date object representing Oct 5, 2023
+ * parseDate('14:30:00', 'HH:mm:ss');     // Date object with today's date and time 14:30:00
+ * parseDate('invalid', 'yyyy-MM-dd');    // null
+ */
+export function parseDate(string, format) {
+  if (typeof string !== 'string' || !format) return null
+
+  const today = new Date()
+  const defaults = {
+    year: today.getFullYear(),
+    month: 0,
+    day: 1,
+    hours: 0,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0, // 新增：默认毫秒为0
+  }
+
+  const tokenDefs = [
+    { key: 'YYYY', regex: '(\\d{4})', type: 'year' },
+    { key: 'yyyy', regex: '(\\d{4})', type: 'year' },
+    { key: 'yyy', regex: '(\\d{3})', type: 'year' },
+    { key: 'YY', regex: '(\\d{2})', type: 'yy' },
+    { key: 'yy', regex: '(\\d{2})', type: 'yy' },
+    { key: 'y', regex: '(\\d{1,4})', type: 'year' },
+    { key: 'MMMM', regex: '(January|February|March|April|May|June|July|August|September|October|November|December)', type: 'monthName' },
+    { key: 'MMM', regex: '(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)', type: 'monthAbbr' },
+    { key: 'MM', regex: '(\\d{2})', type: 'month' },
+    { key: 'M', regex: '(\\d{1,2})', type: 'month' },
+    { key: 'dd', regex: '(\\d{2})', type: 'day' },
+    { key: 'DD', regex: '(\\d{2})', type: 'day' },
+    { key: 'd', regex: '(\\d{1,2})', type: 'day' },
+    { key: 'HH', regex: '(\\d{2})', type: 'HH' },
+    { key: 'H', regex: '(\\d{1,2})', type: 'HH' },
+    { key: 'hh', regex: '(\\d{2})', type: 'h12' },
+    { key: 'h', regex: '(\\d{1,2})', type: 'h12' },
+    { key: 'mm', regex: '(\\d{2})', type: 'mm' },
+    { key: 'm', regex: '(\\d{1,2})', type: 'm' },
+    { key: 'ss', regex: '(\\d{2})', type: 'ss' },
+    { key: 's', regex: '(\\d{1,2})', type: 's' },
+    { key: 'SSS', regex: '(\\d{1,3})', type: 'milliseconds' }, // 新增：毫秒解析定义
+    { key: 'A', regex: '(AM|PM)', type: 'AMPM' },
+    { key: 'a', regex: '(am|pm)', type: 'AMPM' },
+  ]
+
+  // ... (中间的 defMap 和 sortedKeys 生成逻辑保持不变) ...
+  
+  const defMap = {}
+  for (const def of tokenDefs) {
+    defMap[def.key] = def
+  }
+
+  const sortedKeys = tokenDefs.map(d => d.key).sort((a, b) => b.length - a.length)
+
+  let regexStr = ''
+  let pos = 0
+  const groupMap = []
+
+  while (pos < format.length) {
+    let matched = false
+    for (const key of sortedKeys) {
+      const def = defMap[key]
+      if (format.slice(pos, pos + key.length) === key) {
+        regexStr += def.regex
+        groupMap.push({ key, type: def.type })
+        pos += key.length
+        matched = true
+        break
+      }
+    }
+    if (!matched) {
+      const ch = format[pos]
+      regexStr += (/[.*+?^${}()|[\]\\]/.test(ch)) ? '\\' + ch : ch
+      pos++
+    }
+  }
+
+  const finalRegex = new RegExp('^' + regexStr + '$')
+  const match = string.match(finalRegex)
+  if (!match) return null
+
+  const result = { ...defaults }
+
+  for (let i = 0; i < groupMap.length; i++) {
+    const val = match[i + 1]
+    const { key, type } = groupMap[i]
+
+    switch (type) {
+      case 'year':
+        result.year = parseInt(val, 10)
+        break
+      case 'yy':
+        result.year = parseInt(val, 10) + (parseInt(val, 10) < 69 ? 2000 : 1900)
+        break
+      case 'monthName':
+        result.month = ['', 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'].indexOf(val) - 1
+        break
+      case 'monthAbbr':
+        result.month = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'].indexOf(val)
+        break
+      case 'month':
+        result.month = parseInt(val, 10) - 1
+        break
+      case 'day':
+        result.day = parseInt(val, 10)
+        break
+      case 'HH':
+        result.hours = parseInt(val, 10)
+        break
+      case 'h12':
+        result.hours = parseInt(val, 10)
+        break
+      case 'mm':
+        result.minutes = parseInt(val, 10)
+        break
+      case 'm':
+        result.minutes = parseInt(val, 10)
+        break
+      case 'ss':
+        result.seconds = parseInt(val, 10)
+        break
+      case 's':
+        result.seconds = parseInt(val, 10)
+        break
+      case 'milliseconds': // 新增：处理毫秒
+        result.milliseconds = parseInt(val, 10)
+        break
+      case 'AMPM':
+        if (val.toUpperCase() === 'PM' && result.hours !== 12) result.hours += 12
+        if (val.toUpperCase() === 'AM' && result.hours === 12) result.hours = 0
+        break
+    }
+  }
+
+  // 修改：创建 Date 时传入 milliseconds
+  return new Date(result.year, result.month, result.day, result.hours, result.minutes, result.seconds, result.milliseconds)
+}
+
+/* -------------------------------------------------------------------------- */
+/*                              日期 / 时间修改                              */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * 修改日期对象的年月日部分，返回新的 Date 对象（不修改原对象）
+ * 
+ * 未提供的参数将保留原日期对象的对应值。
+ *
+ * @param {Date} date - 原始日期对象
+ * @param {number} [year] - 新的年份
+ * @param {number} [month] - 新的月份 (0-11, 0代表一月)
+ * @param {number} [day] - 新的日期 (1-31)
+ * @returns {Date} 新的日期对象
+ * 
+ * @example
+ * const date = new Date(2023, 0, 15);
+ * modifyDate(date, 2024); // Jan 15, 2024
+ * modifyDate(date, undefined, 5); // Jun 15, 2023
+ */
+export function modifyDate(date, year, month, day) {
+  if (!(date instanceof Date)) return new Date()
+  return new Date(
+    year !== undefined ? year : date.getFullYear(),
+    month !== undefined ? month : date.getMonth(),
+    day !== undefined ? day : date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds(),
+    date.getMilliseconds() // 新增：保留毫秒
+  )
+}
+
+/**
+ * 修改日期对象的时间部分，返回新的 Date 对象
+ *
+ * @param {Date} date - 原始日期对象
+ * @param {number} hours - 小时 (0-23)
+ * @param {number} minutes - 分钟 (0-59)
+ * @param {number} [seconds=0] - 秒 (0-59)，默认为 0
+ * @param {number} [milliseconds=0] - 毫秒 (0-999)，默认为 0
+ * @returns {Date} 新的日期对象
+ * 
+ * @example
+ * const date = new Date(2023, 0, 15, 10, 0, 0);
+ * modifyTime(date, 14, 30); // 2023-01-15 14:30:00
+ */
+export function modifyTime(date, hours, minutes, seconds = 0, milliseconds = 0) { // 新增参数
+  if (!(date instanceof Date)) return new Date()
+  return new Date(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    hours,
+    minutes,
+    seconds,
+    milliseconds // 新增：使用传入的毫秒
+  )
+}
+
+/**
+ * 使用时间字符串修改日期对象的时间部分
+ *
+ * @param {Date} date - 原始日期对象
+ * @param {string} timeString - 时间字符串，格式为 'HH:mm:ss' 或 'HH:mm'
+ * @returns {Date} 新的日期对象
+ * 
+ * @example
+ * const date = new Date(2023, 0, 15);
+ * modifyWithTimeString(date, '14:30:00'); // 2023-01-15 14:30:00
+ * modifyWithTimeString(date, '09:05');    // 2023-01-15 09:05:00
+ */
+export function modifyWithTimeString(date, timeString) {
+  if (!(date instanceof Date) || !timeString) return date instanceof Date ? new Date(date) : new Date()
+  const parts = timeString.split(':')
+  const hours = parseInt(parts[0], 10) || 0
+  const minutes = parseInt(parts[1], 10) || 0
+  const seconds = parseInt(parts[2], 10) || 0
+  return modifyTime(date, hours, minutes, seconds)
+}
+
+/**
+ * 清除日期对象的毫秒部分
+ *
+ * @param {Date} date - 原始日期对象
+ * @returns {Date} 新的日期对象（毫秒设为 0）
+ */
+export function clearMilliseconds(date) {
+  if (!(date instanceof Date)) return new Date()
+  return new Date(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate(),
+    date.getHours(),
+    date.getMinutes(),
+    date.getSeconds()
+  )
+}
+
+/**
+ * 将日期对象的时间部分清零（设置为当天的 00:00:00.000）
+ *
+ * @param {Date} date - 原始日期对象
+ * @returns {Date} 新的日期对象
+ * 
+ * @example
+ * const date = new Date(2023, 0, 15, 14, 30, 0);
+ * clearTime(date); // 2023-01-15 00:00:00
+ */
+export function clearTime(date) {
+  if (!(date instanceof Date)) return new Date()
+  return new Date(
+    date.getFullYear(),
+    date.getMonth(),
+    date.getDate()
+  )
+}
+
+/* -------------------------------------------------------------------------- */
+/*                             日期推算 / 偏移                                */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * 计算指定日期前 N 年的日期
+ *
+ * @param {Date} date - 原始日期
+ * @param {number} [amount=1] - 向前推移的年数
+ * @returns {Date} 新的日期对象
+ */
+export function prevYear(date, amount = 1) {
+  if (!(date instanceof Date)) return new Date()
+  return new Date(date.getFullYear() - amount, date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds())
+}
+
+/**
+ * 计算指定日期后 N 年的日期
+ *
+ * @param {Date} date - 原始日期
+ * @param {number} [amount=1] - 向后推移的年数
+ * @returns {Date} 新的日期对象
+ */
+export function nextYear(date, amount = 1) {
+  if (!(date instanceof Date)) return new Date()
+  return new Date(date.getFullYear() + amount, date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds())
+}
+
+/**
+ * 计算指定日期前 N 个月的日期
+ * 
+ * 自动处理月末日期溢出情况（例如：3月31日前推一个月变为2月28日或29日）。
+ *
+ * @param {Date} date - 原始日期
+ * @param {number} [amount=1] - 向前推移的月数
+ * @returns {Date} 新的日期对象
+ */
+export function prevMonth(date, amount = 1) {
+  if (!(date instanceof Date)) return new Date()
+  const targetMonth = date.getMonth() - amount
+  const targetYear = date.getFullYear() + Math.floor(targetMonth / 12)
+  const normalizedMonth = ((targetMonth % 12) + 12) % 12
+  const maxDay = getDaysInMonth(targetYear, normalizedMonth)
+  return new Date(targetYear, normalizedMonth, Math.min(date.getDate(), maxDay), date.getHours(), date.getMinutes(), date.getSeconds())
+}
+
+/**
+ * 计算指定日期后 N 个月的日期
+ * 
+ * 自动处理月末日期溢出情况。
+ *
+ * @param {Date} date - 原始日期
+ * @param {number} [amount=1] - 向后推移的月数
+ * @returns {Date} 新的日期对象
+ */
+export function nextMonth(date, amount = 1) {
+  if (!(date instanceof Date)) return new Date()
+  return prevMonth(date, -amount)
+}
+
+/**
+ * 计算指定日期前/后 N 天的日期
+ *
+ * @param {Date} date - 原始日期
+ * @param {number} amount - 天数，正数表示向后，负数表示向前
+ * @returns {Date} 新的日期对象
+ * 
+ * @example
+ * nextDate(new Date(), 1);  // 明天
+ * nextDate(new Date(), -1); // 昨天
+ */
+export function nextDate(date, amount) {
+  if (!(date instanceof Date)) return new Date()
+  return new Date(date.getFullYear(), date.getMonth(), date.getDate() + amount, date.getHours(), date.getMinutes(), date.getSeconds())
+}
+
+/**
+ * 修改日期的年和月，并对“日”进行钳制以防止溢出
+ * 
+ * 例如：将 1月31日 改为 2月，结果会是 2月28日（或29日），而不是3月3日。
+ *
+ * @param {Date} date - 原始日期
+ * @param {number} year - 目标年份
+ * @param {number} month - 目标月份 (0-11)
+ * @returns {Date} 新的日期对象
+ */
+export function changeYearMonthAndClampDate(date, year, month) {
+  if (!(date instanceof Date)) return new Date()
+  const daysInMonth = getDaysInMonth(year, month)
+  const clampedDate = Math.min(date.getDate(), daysInMonth)
+  return new Date(year, month, clampedDate, date.getHours(), date.getMinutes(), date.getSeconds())
+}
+
+/* -------------------------------------------------------------------------- */
+/*                              辅助工具函数                                  */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * 获取指定年月的总天数
+ *
+ * @param {number} year - 年份
+ * @param {number} month - 月份 (0-11)
+ * @returns {number} 该月的天数
+ */
+export function getDaysInMonth(year, month) {
+  if (month < 0) month += 12
+  return new Date(year, month + 1, 0).getDate()
+}
+
+/**
+ * 获取指定日期在当年中的 ISO 8601 周数
+ *
+ * @param {Date} date - 日期对象
+ * @returns {number} 周数 (1-53)
+ */
+export function getWeekNumber(date) {
+  if (!(date instanceof Date)) return 0
+  const tempDate = new Date(date.getTime())
+  const dayOfWeek = tempDate.getDay() || 7
+  tempDate.setUTCDate(tempDate.getUTCDate() + 4 - dayOfWeek)
+  const yearStart = new Date(Date.UTC(tempDate.getUTCFullYear(), 0, 1))
+  return Math.ceil((((tempDate - yearStart) / 86400000) + 1) / 7)
+}
+
+/**
+ * 判断值是否为有效的 Date 对象
+ *
+ * @param {*} val - 任意值
+ * @returns {boolean} 如果是有效日期对象返回 true，否则返回 false
+ */
+export function isDate(val) {
+  return val instanceof Date && !isNaN(val.getTime())
+}
+
+/**
+ * 判断值是否为 Date 对象实例（不检查有效性）
+ *
+ * @param {*} val - 任意值
+ * @returns {boolean} 如果是 Date 实例返回 true，否则返回 false
+ */
+export function isDateObject(val) {
+  return val instanceof Date
+}
+
+/**
+ * 判断指定日期是否在给定的时间范围内
+ * 
+ * 范围可以包含多个区间。比较逻辑先比较日期字符串，再比较时间字符串。
+ *
+ * @param {Date} date - 待验证的日期
+ * @param {Date[][]} ranges - 范围数组，每个元素为 [startDate, endDate]
+ * @param {string} format - 格式化模板（目前内部固定使用 'yyyy-MM-dd' 和 'HH:mm:ss' 进行比较，此参数保留用于扩展）
+ * @returns {boolean} 如果日期在任意一个范围内返回 true，否则返回 false
+ */
+export function timeWithinRange(date, ranges, format) {
+  if (!ranges || ranges.length === 0) return true
+  if (!Array.isArray(ranges[0])) {
+    ranges = [ranges]
+  }
+
+  const dateStr = formatDate(date, 'yyyy-MM-dd')
+  for (const range of ranges) {
+    const min = range[0]
+    const max = range[1]
+    if (!min || !max) continue
+
+    const minStr = formatDate(min, 'yyyy-MM-dd')
+    const maxStr = formatDate(max, 'yyyy-MM-dd')
+
+    if (dateStr > maxStr || dateStr < minStr) continue
+
+    const timeStr = formatDate(date, 'HH:mm:ss')
+    const minTimeStr = formatDate(min, 'HH:mm:ss')
+    const maxTimeStr = formatDate(max, 'HH:mm:ss')
+
+    if (timeStr >= minTimeStr && timeStr <= maxTimeStr) return true
+  }
+  return false
+}
+
+/**
+ * 将日期限制在指定范围内
+ * 
+ * 如果日期在范围内，返回原日期副本；
+ * 如果日期超出范围但第二天在范围内，返回第二天的日期；
+ * 否则返回距离最近的边界日期。
+ *
+ * @param {Date} date - 原始日期
+ * @param {Date[][]} ranges - 范围数组，每个元素为 [startDate, endDate]
+ * @param {string} format - 格式化模板（保留参数，当前未直接使用）
+ * @returns {Date} 限制后的日期对象
+ */
+export function limitTimeRange(date, ranges, format) {
+  if (!ranges || ranges.length === 0) return date instanceof Date ? new Date(date) : new Date()
+  const time = date.getTime()
+  const nextDayTime = time + 86400000
+  for (const range of ranges) {
+    const minTime = range[0].getTime()
+    const maxTime = range[1].getTime()
+    if (time >= minTime && time <= maxTime) return date
+    if (time + 86400000 >= minTime && time + 86400000 <= maxTime) {
+      const newDate = new Date(time + 86400000)
+      return modifyDate(date, newDate.getFullYear(), newDate.getMonth(), newDate.getDate())
+    }
+  }
+  // Find closest time
+  let closest = ranges[0][0]
+  let minDiff = Math.abs(time - ranges[0][0].getTime())
+  for (const range of ranges) {
+    for (const boundary of range) {
+      const diff = Math.abs(time - boundary.getTime())
+      if (diff < minDiff) {
+        minDiff = diff
+        closest = boundary
+      }
+    }
+  }
+  return closest instanceof Date ? new Date(closest) : new Date()
+}
+
+/**
+ * 从包含日期和时间的完整格式模板中提取日期部分的格式
+ *
+ * @param {string} format - 完整格式模板，如 'yyyy-MM-dd HH:mm:ss'
+ * @returns {string} 提取后的日期格式，如 'yyyy-MM-dd'
+ * 
+ * @example
+ * extractDateFormat('yyyy-MM-dd HH:mm:ss'); // 'yyyy-MM-dd'
+ * extractDateFormat('HH:mm:ss');            // '' (或者根据实现可能返回空，具体看extractFormatPart逻辑，通常期望返回空或默认值)
+ */
+export function extractDateFormat(format) {
+  if (!format) return 'yyyy-MM-dd'
+  const dateTokens = ['YYYY', 'yyyy', 'yyy', 'YY', 'yy', 'y', 'MMMM', 'MMM', 'MM', 'M', 'dd', 'DD', 'd']
+  const timeTokens = ['HH', 'H', 'hh', 'h', 'mm', 'm', 'ss', 's', 'A', 'a']
+  return extractFormatPart(format, dateTokens, timeTokens)
+}
+
+/**
+ * 从包含日期和时间的完整格式模板中提取时间部分的格式
+ *
+ * @param {string} format - 完整格式模板，如 'yyyy-MM-dd HH:mm:ss'
+ * @returns {string} 提取后的时间格式，如 'HH:mm:ss'
+ * 
+ * @example
+ * extractTimeFormat('yyyy-MM-dd HH:mm:ss'); // 'HH:mm:ss'
+ */
+export function extractTimeFormat(format) {
+  if (!format) return 'HH:mm:ss'
+  const timeTokens = ['HH', 'H', 'hh', 'h', 'mm', 'm', 'ss', 's', 'A', 'a']
+  const dateTokens = ['YYYY', 'yyyy', 'yyy', 'YY', 'yy', 'y', 'MMMM', 'MMM', 'MM', 'M', 'dd', 'DD', 'd']
+  return extractFormatPart(format, timeTokens, dateTokens)
+}
+
+/**
+ * 内部辅助函数：从格式模板中提取指定类型的 token 及其相邻分隔符
+ *
+ * @private
+ * @param {string} format - 格式模板
+ * @param {string[]} includeTokens - 需要保留的 token 列表
+ * @param {string[]} excludeTokens - 需要排除的 token 列表
+ * @returns {string} 提取后的格式字符串
+ */
+function extractFormatPart(format, includeTokens, excludeTokens) {
+  const sortedInclude = [...includeTokens].sort((a, b) => b.length - a.length)
+  const sortedExclude = [...excludeTokens].sort((a, b) => b.length - a.length)
+
+  const segments = []
+  let pos = 0
+
+  while (pos < format.length) {
+    let consumed = false
+
+    for (const token of sortedExclude) {
+      if (format.slice(pos, pos + token.length) === token) {
+        segments.push({ text: token, type: 'time' })
+        pos += token.length
+        consumed = true
+        break
+      }
+    }
+    if (consumed) continue
+
+    for (const token of sortedInclude) {
+      if (format.slice(pos, pos + token.length) === token) {
+        segments.push({ text: token, type: 'date' })
+        pos += token.length
+        consumed = true
+        break
+      }
+    }
+    if (consumed) continue
+
+    segments.push({ text: format[pos], type: 'sep' })
+    pos++
+  }
+
+  const dateSegments = segments.filter((seg, i) => {
+    if (seg.type === 'date') return true
+    if (seg.type !== 'sep') return false
+
+    let hasDateBefore = false
+    for (let j = i - 1; j >= 0; j--) {
+      if (segments[j].type === 'date') { hasDateBefore = true; break }
+      if (segments[j].type === 'time') break
+    }
+
+    let hasDateAfter = false
+    for (let j = i + 1; j < segments.length; j++) {
+      if (segments[j].type === 'date') { hasDateAfter = true; break }
+      if (segments[j].type === 'time') break
+    }
+
+    return hasDateBefore || hasDateAfter
+  })
+
+  return dateSegments.map(s => s.text).join('').replace(/\s+/g, ' ').trim()
+}
+
+/**
+ * 过滤数组，仅保留有效的 Date 对象
+ *
+ * @param {Date[]} dates - 日期数组
+ * @returns {Date[]} 仅包含有效 Date 对象的新数组
+ */
+export function validTimeFormat(dates) {
+  return dates.filter(d => d instanceof Date && !isNaN(d.getTime()))
+}
+
+/* -------------------------------------------------------------------------- */
+/*                                 Moment 兼容接口                             */
+/* -------------------------------------------------------------------------- */
+
+/**
+ * Moment 兼容类
+ * 支持类似 moment(date).format('YYYY-MM-DD') 的调用方式
+ */
+class Moment {
+  constructor(input, format) {
+    this._d = null; 
+
+    if (input instanceof Date) {
+      this._d = new Date(input.getTime()); // 自动包含毫秒
+    } else if (typeof input === 'number') {
+      this._d = new Date(input); // 时间戳自动包含毫秒
+    } else if (typeof input === 'string') {
+      if (format) {
+        this._d = parseDate(input, format); // parseDate 现在支持毫秒
+      } else {
+        this._d = new Date(input);
+      }
+    } else if (input === undefined || input === null) {
+      this._d = new Date();
+    } else {
+      this._d = new Date();
+    }
+  }
+
+  // ... toDate, isValid, format 保持不变 ...
+
+  set(key, value) {
+    if (!this.isValid()) return this;
+    
+    let y = this._d.getFullYear();
+    let m = this._d.getMonth();
+    let d = this._d.getDate();
+    let h = this._d.getHours();
+    let min = this._d.getMinutes();
+    let s = this._d.getSeconds();
+    let ms = this._d.getMilliseconds(); // 新增：获取当前毫秒
+
+    switch (key) {
+      case 'year':
+      case 'years':
+        y = value;
+        break;
+      case 'month':
+      case 'months':
+        m = value;
+        break;
+      case 'date':
+      case 'dates':
+      case 'day':
+      case 'days':
+        d = value;
+        break;
+      case 'hour':
+      case 'hours':
+        h = value;
+        break;
+      case 'minute':
+      case 'minutes':
+        min = value;
+        break;
+      case 'second':
+      case 'seconds':
+        s = value;
+        break;
+      case 'millisecond': // 新增：支持设置毫秒
+      case 'milliseconds':
+        ms = value;
+        break;
+    }
+
+    this._d = new Date(y, m, d, h, min, s, ms); // 修改：传入毫秒
+    return this;
+  }
+
+  get(key) {
+    if (!this.isValid()) return NaN;
+    switch (key) {
+      case 'year':
+      case 'years':
+        return this._d.getFullYear();
+      case 'month':
+      case 'months':
+        return this._d.getMonth();
+      case 'date':
+      case 'dates':
+      case 'day':
+      case 'days':
+        return this._d.getDate();
+      case 'hour':
+      case 'hours':
+        return this._d.getHours();
+      case 'minute':
+      case 'minutes':
+        return this._d.getMinutes();
+      case 'second':
+      case 'seconds':
+        return this._d.getSeconds();
+      case 'millisecond': // 新增：支持获取毫秒
+      case 'milliseconds':
+        return this._d.getMilliseconds();
+      default:
+        return NaN;
+    }
+  }
+
+  // add, subtract, startOf, endOf 等方法中，如果涉及新建 Date 对象，建议显式传递毫秒
+  // 例如 startOf('day') 应该将毫秒也清零
+  
+  startOf(unit) {
+    if (!this.isValid()) return this;
+    let y = this._d.getFullYear();
+    let m = this._d.getMonth();
+    let d = this._d.getDate();
+
+    switch (unit) {
+      case 'year':
+        this._d = new Date(y, 0, 1, 0, 0, 0, 0); // 显式置零毫秒
+        break;
+      case 'month':
+        this._d = new Date(y, m, 1, 0, 0, 0, 0); // 显式置零毫秒
+        break;
+      case 'day':
+        this._d = new Date(y, m, d, 0, 0, 0, 0); // 显式置零毫秒
+        break;
+    }
+    return this;
+  }
+
+  endOf(unit) {
+    if (!this.isValid()) return this;
+    let y = this._d.getFullYear();
+    let m = this._d.getMonth();
+    
+    switch (unit) {
+      case 'year':
+        this._d = new Date(y, 11, 31, 23, 59, 59, 999); // 显式设为999
+        break;
+      case 'month':
+        const days = getDaysInMonth(y, m);
+        this._d = new Date(y, m, days, 23, 59, 59, 999); // 显式设为999
+        break;
+      case 'day':
+        this._d = new Date(y, m, d, 23, 59, 59, 999); // 显式设为999
+        break;
+    }
+    return this;
+  }
+
+  /**
+   * 比较是否相同
+   * @param {Moment|Date} other 
+   * @param {string} unit - 可选，比较精度
+   */
+  isSame(other, unit) {
+    if (!other) return false;
+    const otherDate = other instanceof Moment ? other.toDate() : other;
+    if (!isDate(otherDate)) return false;
+
+    if (unit) {
+       // 简化实现，仅做时间戳比较或特定字段比较
+       // 实际生产环境可能需要更复杂的逻辑
+       const val1 = this.format(extractDateFormat('YYYY-MM-DD')); // 粗略示例
+       // 这里建议根据 unit 提取对应字段比较
+    }
+    return this._d.getTime() === otherDate.getTime();
+  }
+  
+  /**
+   * 比较是否之前
+   */
+  isBefore(other, unit) {
+     const otherDate = other instanceof Moment ? other.toDate() : other;
+     if (!isDate(otherDate)) return false;
+     return this._d.getTime() < otherDate.getTime();
+  }
+
+  /**
+   * 比较是否之后
+   */
+  isAfter(other, unit) {
+    const otherDate = other instanceof Moment ? other.toDate() : other;
+    if (!isDate(otherDate)) return false;
+    return this._d.getTime() > otherDate.getTime();
+  }
+}
+
+/**
+ * 工厂函数：创建 Moment 实例
+ * @param {*} input 
+ * @param {string} format 
+ * @returns {Moment}
+ */
+const momentFactory = function(input, format) {
+  return new Moment(input, format);
+};
+
+// 挂载静态工具方法，方便直接调用，如 moment.parseDate(...)
+momentFactory.parseDate = parseDate;
+momentFactory.formatDate = formatDate;
+momentFactory.modifyDate = modifyDate;
+momentFactory.modifyTime = modifyTime;
+momentFactory.nextDate = nextDate;
+momentFactory.nextMonth = nextMonth;
+momentFactory.nextYear = nextYear;
+momentFactory.prevMonth = prevMonth;
+momentFactory.prevYear = prevYear;
+momentFactory.clearTime = clearTime;
+momentFactory.isDate = isDate;
+momentFactory.getDaysInMonth = getDaysInMonth;
+momentFactory.extractDateFormat = extractDateFormat;
+momentFactory.extractTimeFormat = extractTimeFormat;
+
+// 导出默认对象
+export default momentFactory;