niuma-ui 1.0.0

package/src/components/tabs-utils.ts

@@ -0,0 +1,107 @@
+/** 选项卡项定义 */
+export interface RsTabItem {
+  value: string
+  label: string
+  icon?: string
+  disabled?: boolean
+  badge?: string | number
+  /** 是否可关闭；未设置时继承 RsTabs 的 closable */
+  closable?: boolean
+  /** 是否可重命名；未设置时继承 RsTabs 的 renamable */
+  renamable?: boolean
+}
+
+/** 选项卡尺寸 */
+export type RsTabsSize = 'sm' | 'md'
+
+/** line 下划线 · segmented 胶囊 · card 卡片（Ant editable-card） */
+export type RsTabsVariant = 'line' | 'segmented' | 'card'
+
+/** 标签过多时的处理方式 */
+export type RsTabsOverflow = 'scroll' | 'dropdown'
+
+/** 判断单项是否展示关闭按钮 */
+export function isTabClosable(item: RsTabItem, globalClosable = false): boolean {
+  if (item.closable !== undefined) return item.closable
+  return globalClosable
+}
+
+/** 判断单项是否可双击重命名 */
+export function isTabRenamable(item: RsTabItem, globalRenamable = false): boolean {
+  if (item.renamable !== undefined) return item.renamable
+  return globalRenamable
+}
+
+/** 关闭当前激活项时，解析应切换到的下一项（优先右侧，否则左侧） */
+export function getNextTabAfterClose(
+  items: RsTabItem[],
+  closedValue: string,
+  activeValue: string,
+): string | undefined {
+  if (activeValue !== closedValue) return activeValue
+  const index = items.findIndex((item) => item.value === closedValue)
+  if (index < 0) return undefined
+  const remaining = items.filter((item) => item.value !== closedValue)
+  if (!remaining.length) return undefined
+  return remaining[index]?.value ?? remaining[index - 1]?.value ?? remaining[0]?.value
+}
+
+/** 将 dragValue 对应的项移动到 dropValue 之前 */
+export function reorderTabItems(
+  items: RsTabItem[],
+  dragValue: string,
+  dropValue: string,
+): RsTabItem[] {
+  const from = items.findIndex((item) => item.value === dragValue)
+  const to = items.findIndex((item) => item.value === dropValue)
+  if (from < 0 || to < 0 || from === to) return items
+  const next = [...items]
+  const [moved] = next.splice(from, 1)
+  if (!moved) return items
+  next.splice(to, 0, moved)
+  return next
+}
+
+export interface ResolveVisibleTabOptions {
+  /** dropdown 模式下为 false：激活项仅在「更多」展示，不占标签栏 */
+  keepActiveVisible?: boolean
+}
+
+/**
+ * 根据各标签宽度与可用宽度，计算应展示的标签 value 集合。
+ */
+export function resolveVisibleTabValues(
+  items: RsTabItem[],
+  widths: Map<string, number>,
+  availableWidth: number,
+  activeValue: string,
+  reservedWidth = 0,
+  options: ResolveVisibleTabOptions = {},
+): Set<string> {
+  const keepActiveVisible = options.keepActiveVisible ?? true
+
+  if (availableWidth <= 0 || !items.length) {
+    return new Set(items.map((item) => item.value))
+  }
+
+  const budget = Math.max(0, availableWidth - reservedWidth)
+  const visible: string[] = []
+  let used = 0
+
+  for (const item of items) {
+    const width = widths.get(item.value) ?? 0
+    if (used + width > budget) break
+    visible.push(item.value)
+    used += width
+  }
+
+  if (keepActiveVisible && !visible.includes(activeValue)) {
+    const activeIndex = items.findIndex((item) => item.value === activeValue)
+    if (activeIndex >= 0) {
+      if (visible.length > 1) visible.pop()
+      if (!visible.includes(activeValue)) visible.push(activeValue)
+    }
+  }
+
+  return new Set(visible)
+}

package/src/components/terminal-utils.ts

@@ -0,0 +1,301 @@
+import type { ITheme, Terminal } from 'xterm'
+import { readDocumentTheme } from './code-editor-utils'
+
+export type RsTerminalThemeMode = 'auto' | 'light' | 'dark'
+export type RsResolvedTerminalTheme = 'light' | 'dark'
+
+export type RsTerminalAction = 'copy' | 'paste' | 'selectAll' | 'clear' | 'askAi'
+
+const TERMINAL_CSS_KEYS: Array<[keyof ITheme, string]> = [
+  ['background', '--rs-terminal-bg'],
+  ['foreground', '--rs-terminal-fg'],
+  ['cursor', '--rs-terminal-cursor'],
+  ['cursorAccent', '--rs-terminal-cursor-accent'],
+  ['selectionBackground', '--rs-terminal-selection-bg'],
+  ['selectionForeground', '--rs-terminal-selection-fg'],
+  ['black', '--rs-terminal-ansi-black'],
+  ['red', '--rs-terminal-ansi-red'],
+  ['green', '--rs-terminal-ansi-green'],
+  ['yellow', '--rs-terminal-ansi-yellow'],
+  ['blue', '--rs-terminal-ansi-blue'],
+  ['magenta', '--rs-terminal-ansi-magenta'],
+  ['cyan', '--rs-terminal-ansi-cyan'],
+  ['white', '--rs-terminal-ansi-white'],
+  ['brightBlack', '--rs-terminal-ansi-bright-black'],
+  ['brightRed', '--rs-terminal-ansi-bright-red'],
+  ['brightGreen', '--rs-terminal-ansi-bright-green'],
+  ['brightYellow', '--rs-terminal-ansi-bright-yellow'],
+  ['brightBlue', '--rs-terminal-ansi-bright-blue'],
+  ['brightMagenta', '--rs-terminal-ansi-bright-magenta'],
+  ['brightCyan', '--rs-terminal-ansi-bright-cyan'],
+  ['brightWhite', '--rs-terminal-ansi-bright-white'],
+]
+
+const themeProbeCache = new Map<RsResolvedTerminalTheme, HTMLElement>()
+
+const TERMINAL_ROW_STRIPE_VAR = '--rs-terminal-row-stripe'
+
+function readCssVar(name: string, element: HTMLElement): string {
+  return getComputedStyle(element).getPropertyValue(name).trim()
+}
+
+function channelToHex(raw: string): string | null {
+  const value = raw.endsWith('%')
+    ? Math.round((Number(raw.slice(0, -1)) / 100) * 255)
+    : Math.round(Number(raw))
+  if (!Number.isFinite(value)) {
+    return null
+  }
+  return Math.max(0, Math.min(255, value)).toString(16).padStart(2, '0')
+}
+
+function parseRgbChannels(value: string): [string, string, string] | null {
+  const lower = value.toLowerCase()
+  if (!lower.startsWith('rgb')) {
+    return null
+  }
+  const open = value.indexOf('(')
+  const close = value.indexOf(')', open + 1)
+  if (open === -1 || close === -1) {
+    return null
+  }
+  const parts = value
+    .slice(open + 1, close)
+    .replaceAll('/', ' ')
+    .replaceAll(',', ' ')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+  if (parts.length < 3) {
+    return null
+  }
+  const r = channelToHex(parts[0])
+  const g = channelToHex(parts[1])
+  const b = channelToHex(parts[2])
+  if (!r || !g || !b) {
+    return null
+  }
+  return [r, g, b]
+}
+
+/** 将 CSS 颜色规范为 #RRGGBB（支持 hex 与 computed rgb） */
+export function normalizeTerminalHexColor(value: string): string | null {
+  const trimmed = value.trim()
+  if (!trimmed) {
+    return null
+  }
+  if (/^#[0-9a-fA-F]{6}$/.test(trimmed)) {
+    return trimmed.toLowerCase()
+  }
+  if (/^#[0-9a-fA-F]{3}$/.test(trimmed)) {
+    const [, r, g, b] = trimmed
+    return `#${r}${r}${g}${g}${b}${b}`.toLowerCase()
+  }
+  const rgb = parseRgbChannels(trimmed)
+  if (!rgb) {
+    return null
+  }
+  return `#${rgb[0]}${rgb[1]}${rgb[2]}`
+}
+
+/** 将 lab()/color() 等现代 CSS 色值转为 xterm 可解析的 #RRGGBB */
+export function resolveCssColorForXterm(value: string): string | null {
+  const direct = normalizeTerminalHexColor(value)
+  if (direct) {
+    return direct
+  }
+  if (typeof document === 'undefined') {
+    return null
+  }
+  const canvas = document.createElement('canvas')
+  canvas.width = 1
+  canvas.height = 1
+  const ctx = canvas.getContext('2d', { willReadFrequently: true })
+  if (!ctx) {
+    return null
+  }
+  try {
+    ctx.fillStyle = '#000000'
+    ctx.fillStyle = value
+    if (typeof ctx.fillStyle !== 'string') {
+      return null
+    }
+    ctx.fillRect(0, 0, 1, 1)
+    const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data
+    if (a === 0) {
+      return null
+    }
+    return `#${[r, g, b].map((c) => c.toString(16).padStart(2, '0')).join('')}`
+  } catch {
+    return null
+  }
+}
+
+const BACKGROUND_THEME_KEYS = new Set<keyof ITheme>(['background', 'selectionBackground'])
+
+function readResolvedCssColor(cssVar: string, source: HTMLElement, asBackground: boolean): string {
+  const probe = document.createElement('span')
+  probe.style.cssText = 'position:absolute;visibility:hidden;pointer-events:none'
+  if (asBackground) {
+    probe.style.backgroundColor = `var(${cssVar})`
+  } else {
+    probe.style.color = `var(${cssVar})`
+  }
+  source.appendChild(probe)
+  const computed = getComputedStyle(probe)
+  const raw = asBackground ? computed.backgroundColor : computed.color
+  probe.remove()
+  return raw
+}
+
+function themeProbeElement(mode: RsResolvedTerminalTheme): HTMLElement {
+  const cached = themeProbeCache.get(mode)
+  if (cached) {
+    return cached
+  }
+  const probe = document.createElement('div')
+  probe.dataset.rsTheme = mode
+  probe.style.cssText = 'position:absolute;visibility:hidden;pointer-events:none'
+  document.body.appendChild(probe)
+  themeProbeCache.set(mode, probe)
+  return probe
+}
+
+function themeSourceElement(mode: RsResolvedTerminalTheme): HTMLElement {
+  if (document.documentElement.dataset.rsTheme === mode) {
+    return document.documentElement
+  }
+  return themeProbeElement(mode)
+}
+
+/** 从全局 `--rs-terminal-*` token 构建 xterm 调色板（须已加载 styles.css） */
+export function readTerminalThemeFromCss(mode: RsResolvedTerminalTheme): ITheme {
+  if (typeof document === 'undefined' || typeof getComputedStyle === 'undefined') {
+    return {}
+  }
+  const source = themeSourceElement(mode)
+  const theme: ITheme = {}
+  for (const [key, cssVar] of TERMINAL_CSS_KEYS) {
+    const raw = readResolvedCssColor(cssVar, source, BACKGROUND_THEME_KEYS.has(key))
+    const value = resolveCssColorForXterm(raw)
+    if (value) {
+      ;(theme as Record<string, string>)[key] = value
+    }
+  }
+  return theme
+}
+
+export function resolveTerminalTheme(mode: RsTerminalThemeMode = 'auto'): RsResolvedTerminalTheme {
+  return mode === 'auto' ? readDocumentTheme() : mode
+}
+
+export function getTerminalThemePalette(mode: RsResolvedTerminalTheme): ITheme {
+  return readTerminalThemeFromCss(mode)
+}
+
+export function mergeTerminalTheme(
+  mode: RsResolvedTerminalTheme,
+  overrides?: Partial<ITheme>,
+): ITheme {
+  return {
+    ...readTerminalThemeFromCss(mode),
+    ...overrides,
+  }
+}
+
+/** 读取斑马纹行底色（`--rs-terminal-row-stripe`，解析后供 xterm decoration 使用） */
+export function readTerminalRowStripeFromCss(mode: RsResolvedTerminalTheme): string {
+  if (typeof document === 'undefined' || typeof getComputedStyle === 'undefined') {
+    return ''
+  }
+  return readCssVar(TERMINAL_ROW_STRIPE_VAR, themeSourceElement(mode))
+}
+
+/** PTY 输出是否含终端控制序列（ESC / CSI），此类数据不应批量延迟。 */
+export function containsEscapeSequence(data: string): boolean {
+  return data.includes('\x1b') || data.includes('\x9b')
+}
+
+const TUI_REFRESH_PATTERN =
+  /\x1b\[[0-9;]*[Hf]|\x1b\[2J|\x1b\[\?1049[hl]|\x1b\[\?47[hl]|\x1b\[1049[hl]/
+
+/** 检测 ncurses/vim/top 等全屏刷新常用的光标定位与清屏序列 */
+export function containsTuiRefreshSequence(data: string): boolean {
+  return TUI_REFRESH_PATTERN.test(data)
+}
+
+const FULL_SCREEN_CLEAR_PATTERN = /\x1b\[[0-9;]*2J|\x1b\[[0-9;]*3J/
+const CURSOR_HOME_TOP_PATTERN = /^\x1b\[H|^\x1b\[1;1H|^\x1b\[1H/
+
+/** 全屏清屏（top/vim 新一轮绘制常见） */
+export function containsFullScreenClear(data: string): boolean {
+  return FULL_SCREEN_CLEAR_PATTERN.test(data)
+}
+
+/** 数据块以光标归位首行开头（top 每轮刷新常见） */
+export function startsWithCursorHome(data: string): boolean {
+  return CURSOR_HOME_TOP_PATTERN.test(data.trimStart())
+}
+
+/**
+ * 在本地解析层重置滚动边距等模式（不发给 PTY）。
+ * 仅在全屏清屏等明确「新一轮绘制」时调用，避免打断进行中的 TUI 光标位置。
+ */
+export function resetLocalTerminalModes(terminal: Terminal): void {
+  terminal.write('\x1b[r')
+}
+
+export function snapTerminalViewportToBottom(terminal: Terminal): void {
+  terminal.scrollToBottom()
+}
+
+/** 处理 PTY 写入前的视口/模式准备（不移动写入光标，避免输入错位） */
+export function prepareTerminalForPtyWrite(terminal: Terminal, data: string): void {
+  if (containsFullScreenClear(data)) {
+    resetLocalTerminalModes(terminal)
+    return
+  }
+  const buffer = terminal.buffer.active
+  if (buffer.viewportY < buffer.baseY) {
+    snapTerminalViewportToBottom(terminal)
+  }
+}
+
+export function isMacPlatform(): boolean {
+  if (typeof navigator === 'undefined') {
+    return false
+  }
+  return /Mac|iPhone|iPad|iPod/.test(navigator.platform)
+}
+
+/** 菜单/文档展示的修饰键标签 */
+export function terminalShortcutLabel(key: string): string {
+  return isMacPlatform() ? `⌘${key}` : `Ctrl+${key}`
+}
+
+/** ANSI 16 色演示文本 */
+export function buildAnsiColorDemo(): string {
+  const names = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white']
+  const rows = [0, 1].map((row) => {
+    const base = row === 0 ? 30 : 90
+    let line = ''
+    for (let i = 0; i < 8; i += 1) {
+      line += `\x1b[${base + i}m ${names[i].padEnd(8)} \x1b[0m`
+    }
+    return line
+  })
+  let gradient = ''
+  for (let i = 16; i < 52; i += 1) {
+    gradient += `\x1b[48;5;${i}m \x1b[0m`
+  }
+  const lines = [
+    '\x1b[1mANSI 16 colors\x1b[0m',
+    ...rows,
+    '',
+    '\x1b[1mStyles\x1b[0m  \x1b[1mbold\x1b[0m  \x1b[3mitalic\x1b[0m  \x1b[4munderline\x1b[0m  \x1b[9mstrikethrough\x1b[0m',
+    '',
+    '\x1b[38;5;196m256-color\x1b[0m sample:',
+    gradient,
+  ]
+  return `${lines.join('\r\n')}\r\n`
+}

package/src/components/terminal-wheel.ts

@@ -0,0 +1,49 @@
+import type { Terminal } from 'xterm'
+
+export type RsTerminalWheelScrollModifier = 'none' | 'shift'
+
+/** 视口是否已滚入 scrollback（非底部跟随） */
+export function isTerminalViewportScrolledUp(terminal: Terminal): boolean {
+  const buffer = terminal.buffer.active
+  return buffer.viewportY < buffer.baseY
+}
+
+/**
+ * 滚轮策略：默认滚轮不翻 scrollback，转为方向键发给 PTY（避免 top/vim 类全屏 TUI 错位）；
+ * 按住 Shift 时滚轮才滚动历史。
+ */
+export function attachWheelScrollGuard(
+  hostEl: HTMLElement,
+  options: {
+    modifier: () => RsTerminalWheelScrollModifier
+    inputEnabled: () => boolean
+    onArrowKeys: (data: string) => void
+  },
+): () => void {
+  const viewport = hostEl.querySelector<HTMLElement>('.xterm-viewport')
+  if (!viewport) {
+    return () => undefined
+  }
+
+  const handler = (ev: WheelEvent): void => {
+    if (options.modifier() === 'none') {
+      return
+    }
+    if (ev.shiftKey) {
+      return
+    }
+    ev.preventDefault()
+    ev.stopImmediatePropagation()
+    if (!options.inputEnabled() || ev.deltaY === 0) {
+      return
+    }
+    const steps = Math.min(5, Math.max(1, Math.round(Math.abs(ev.deltaY) / 40)))
+    const seq = ev.deltaY > 0 ? '\x1b[B' : '\x1b[A'
+    options.onArrowKeys(seq.repeat(steps))
+  }
+
+  viewport.addEventListener('wheel', handler, { capture: true, passive: false })
+  return () => {
+    viewport.removeEventListener('wheel', handler, { capture: true })
+  }
+}

package/src/components/time-picker-utils.ts

@@ -0,0 +1,167 @@
+export interface RsParsedTime {
+  hour: number
+  minute: number
+  second: number
+}
+
+export interface RsTimeRangeValue {
+  start?: string
+  end?: string
+}
+
+export const EMPTY_TIME_RANGE: RsTimeRangeValue = {}
+
+const TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)$/
+const TIME_WITH_SECONDS_PATTERN = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)$/
+
+export function scheduleAfterPaint(callback: () => void): () => void {
+  let cancelled = false
+  requestAnimationFrame(() => {
+    requestAnimationFrame(() => {
+      if (!cancelled) callback()
+    })
+  })
+  return () => {
+    cancelled = true
+  }
+}
+
+export function rangeInclusive(max: number): number[] {
+  return Array.from({ length: max + 1 }, (_, index) => index)
+}
+
+export function parseTimeValue(value?: string, withSeconds = false): RsParsedTime | null {
+  if (!value?.trim()) return null
+  const trimmed = value.trim()
+  const pattern = withSeconds ? TIME_WITH_SECONDS_PATTERN : TIME_PATTERN
+  const match = pattern.exec(trimmed)
+  if (!match) return null
+  return {
+    hour: Number.parseInt(match[1], 10),
+    minute: Number.parseInt(match[2], 10),
+    second: withSeconds ? Number.parseInt(match[3], 10) : 0,
+  }
+}
+
+export function formatTimeParts(hour: number, minute: number, second?: number): string {
+  const h = String(hour).padStart(2, '0')
+  const m = String(minute).padStart(2, '0')
+  if (second !== undefined) return `${h}:${m}:${String(second).padStart(2, '0')}`
+  return `${h}:${m}`
+}
+
+export function formatTimeFromParts(
+  hour: number,
+  minute: number,
+  second: number,
+  withSeconds = false,
+): string {
+  return formatTimeParts(hour, minute, withSeconds ? second : undefined)
+}
+
+export function getCurrentTime(): RsParsedTime {
+  const now = new Date()
+  return {
+    hour: now.getHours(),
+    minute: now.getMinutes(),
+    second: now.getSeconds(),
+  }
+}
+
+export function formatTimeValue(value?: string): string {
+  return value ?? ''
+}
+
+export function timeToSeconds(hour: number, minute: number, second = 0): number {
+  return hour * 3600 + minute * 60 + second
+}
+
+export function parseTimeToSeconds(value: string, withSeconds = false): number | null {
+  const parsed = parseTimeValue(value, withSeconds)
+  if (!parsed) return null
+  return timeToSeconds(parsed.hour, parsed.minute, parsed.second)
+}
+
+export function isTimeWithinBounds(
+  hour: number,
+  minute: number,
+  second: number,
+  options: { minTime?: string; maxTime?: string; withSeconds?: boolean } = {},
+): boolean {
+  const { minTime, maxTime, withSeconds = false } = options
+  const candidate = timeToSeconds(hour, minute, second)
+
+  if (minTime) {
+    const minSeconds = parseTimeToSeconds(minTime, withSeconds)
+    if (minSeconds !== null && candidate < minSeconds) return false
+  }
+
+  if (maxTime) {
+    const maxSeconds = parseTimeToSeconds(maxTime, withSeconds)
+    if (maxSeconds !== null && candidate > maxSeconds) return false
+  }
+
+  return true
+}
+
+export function isTimeRangeEmpty(value: RsTimeRangeValue): boolean {
+  return !value.start?.trim() && !value.end?.trim()
+}
+
+export function isTimeRangeOrdered(
+  range: RsTimeRangeValue,
+  withSeconds = false,
+): boolean {
+  if (!range.start || !range.end) return true
+  return isTimeRangeOrderedValues(range.start, range.end, withSeconds)
+}
+
+export function isTimeRangeOrderedValues(
+  start: string,
+  end: string,
+  withSeconds = false,
+): boolean {
+  const startSeconds = parseTimeToSeconds(start, withSeconds)
+  const endSeconds = parseTimeToSeconds(end, withSeconds)
+  if (startSeconds === null || endSeconds === null) return true
+  return startSeconds <= endSeconds
+}
+
+export function pickEarlierTime(
+  a?: string,
+  b?: string,
+  withSeconds = false,
+): string | undefined {
+  if (!a) return b
+  if (!b) return a
+  const ta = parseTimeToSeconds(a, withSeconds)
+  const tb = parseTimeToSeconds(b, withSeconds)
+  if (ta === null) return b
+  if (tb === null) return a
+  return ta <= tb ? a : b
+}
+
+export function pickLaterTime(
+  a?: string,
+  b?: string,
+  withSeconds = false,
+): string | undefined {
+  if (!a) return b
+  if (!b) return a
+  const ta = parseTimeToSeconds(a, withSeconds)
+  const tb = parseTimeToSeconds(b, withSeconds)
+  if (ta === null) return b
+  if (tb === null) return a
+  return ta >= tb ? a : b
+}
+
+export function formatTimeRangeDisplay(
+  range: RsTimeRangeValue,
+  options?: { separator?: string },
+): string {
+  const separator = options?.separator ?? ' ~ '
+  const start = range.start ? formatTimeValue(range.start) : ''
+  const end = range.end ? formatTimeValue(range.end) : ''
+  if (start && end) return `${start}${separator}${end}`
+  return start || end
+}

package/src/components/time-range-validation.ts

@@ -0,0 +1,23 @@
+import type { RsTimeRangeValue } from './time-picker-utils'
+import { isTimeRangeOrdered } from './time-picker-utils'
+
+export interface RsTimeRangeValidationRules {
+  required?: boolean
+  ordered?: boolean
+}
+
+export type RsTimeRangeValidationError = 'required' | 'order'
+
+export interface RsTimeRangeValidationResult {
+  valid: boolean
+  error?: RsTimeRangeValidationError
+}
+
+export function validateTimeRangeValue(
+  value: RsTimeRangeValue,
+  rules: RsTimeRangeValidationRules = {},
+): RsTimeRangeValidationResult {
+  if (rules.required && (!value.start || !value.end)) return { valid: false, error: 'required' }
+  if (rules.ordered !== false && !isTimeRangeOrdered(value)) return { valid: false, error: 'order' }
+  return { valid: true }
+}

package/src/components/time-validation.ts

@@ -0,0 +1,20 @@
+export interface RsTimeValidationRules {
+  required?: boolean
+  min?: string
+  max?: string
+}
+
+export type RsTimeValidationError = 'required' | 'min' | 'max' | 'format'
+
+export interface RsTimeValidationResult {
+  valid: boolean
+  error?: RsTimeValidationError
+}
+
+export function validateTimeValue(value: string, rules: RsTimeValidationRules = {}): RsTimeValidationResult {
+  if (!value) return rules.required ? { valid: false, error: 'required' } : { valid: true }
+  if (!/^\d{2}:\d{2}(?::\d{2})?$/.test(value)) return { valid: false, error: 'format' }
+  if (rules.min && value < rules.min) return { valid: false, error: 'min' }
+  if (rules.max && value > rules.max) return { valid: false, error: 'max' }
+  return { valid: true }
+}