@linxin666/dsh-remote-web-ui 0.3.6 → 0.3.9

package/src/mobile/mobile-theme.test.ts

@@ -1,84 +0,0 @@
-// @vitest-environment jsdom
-/** mobile-theme: light default, persisted dark toggle, document wiring. */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import {
-  getMobileTheme, setMobileTheme, subscribeMobileTheme, toggleMobileTheme,
-} from './mobile-theme.ts'
-
-const STORAGE_KEY = 'dsh.remote.theme'
-
-/** jsdom in this setup ships a bare localStorage object; install a real fake. */
-function makeStorage(): Storage {
-  const map = new Map<string, string>()
-  return {
-    getItem: (key: string) => map.get(key) ?? null,
-    setItem: (key: string, value: string) => { map.set(key, value) },
-    removeItem: (key: string) => { map.delete(key) },
-    clear: () => { map.clear() },
-    key: (index: number) => [...map.keys()][index] ?? null,
-    get length() { return map.size },
-  } as Storage
-}
-
-let storage: Storage
-
-beforeEach(() => {
-  storage = makeStorage()
-  vi.stubGlobal('localStorage', storage)
-  setMobileTheme('light')
-  document.documentElement.removeAttribute('data-theme')
-})
-
-afterEach(() => {
-  vi.unstubAllGlobals()
-})
-
-describe('mobile-theme', () => {
-  it('defaults to light with nothing stored', () => {
-    expect(getMobileTheme()).toBe('light')
-  })
-
-  it('toggles to dark, persists it, and wires the document', () => {
-    expect(toggleMobileTheme()).toBe('dark')
-    expect(getMobileTheme()).toBe('dark')
-    expect(document.documentElement.dataset.theme).toBe('dark')
-    expect(storage.getItem(STORAGE_KEY)).toBe('dark')
-  })
-
-  it('toggles back to light', () => {
-    toggleMobileTheme()
-    expect(toggleMobileTheme()).toBe('light')
-    expect(document.documentElement.dataset.theme).toBe('light')
-    expect(storage.getItem(STORAGE_KEY)).toBe('light')
-  })
-
-  it('updates the browser chrome color along with the theme', () => {
-    const meta = document.createElement('meta')
-    meta.name = 'theme-color'
-    document.head.appendChild(meta)
-    setMobileTheme('dark')
-    expect(meta.content).toBe('#111418')
-    setMobileTheme('light')
-    expect(meta.content).toBe('#f3f5f9')
-    meta.remove()
-  })
-
-  it('boot reads the stored theme and initMobileTheme applies it', async () => {
-    storage.setItem(STORAGE_KEY, 'dark')
-    vi.resetModules()
-    const fresh = await import('./mobile-theme.ts')
-    expect(fresh.getMobileTheme()).toBe('dark')
-    fresh.initMobileTheme()
-    expect(document.documentElement.dataset.theme).toBe('dark')
-  })
-
-  it('notifies subscribers on change', () => {
-    const seen: string[] = []
-    const unsubscribe = subscribeMobileTheme(() => { seen.push(getMobileTheme()) })
-    setMobileTheme('dark')
-    setMobileTheme('light')
-    unsubscribe()
-    setMobileTheme('dark')
-    expect(seen).toEqual(['dark', 'light'])
-  })
-})

package/src/mobile/mobile-theme.ts

@@ -1,76 +0,0 @@
-/**
- * Mobile-surface theme: light by default, dark via an explicit persisted
- * toggle. The standalone page boots without the shell, so there is no theme
- * system to inherit — the choice is stored in localStorage and applied as a
- * `data-theme` attribute on <html>; the stylesheet defines both palettes
- * under `:root` (light) / `:root[data-theme='dark']` (dark).
- *
- * A tiny module store (subscribe/get) keeps the toggle button and the boot
- * path in sync without threading props through the three view levels.
- */
-
-export type MobileTheme = 'light' | 'dark'
-
-const STORAGE_KEY = 'dsh.remote.theme'
-const THEME_COLOR_META_NAME = 'theme-color'
-const LIGHT_THEME_COLOR = '#f3f5f9'
-const DARK_THEME_COLOR = '#111418'
-
-let current: MobileTheme = readStored() ?? 'light'
-const listeners = new Set<() => void>()
-
-function readStored(): MobileTheme | undefined {
-  try {
-    const value = localStorage.getItem(STORAGE_KEY)
-    return value === 'dark' || value === 'light' ? value : undefined
-  } catch {
-    return undefined
-  }
-}
-
-function persist(theme: MobileTheme): void {
-  try {
-    localStorage.setItem(STORAGE_KEY, theme)
-  } catch {
-    // Private-mode storage failures are non-fatal; the session keeps the theme.
-  }
-}
-
-/** Apply the theme to the document: data-theme attribute + browser chrome color. */
-function applyToDocument(theme: MobileTheme): void {
-  if (typeof document === 'undefined') return
-  document.documentElement.dataset.theme = theme
-  const meta = document.querySelector<HTMLMetaElement>(`meta[name="${THEME_COLOR_META_NAME}"]`)
-  if (meta !== null) meta.content = theme === 'dark' ? DARK_THEME_COLOR : LIGHT_THEME_COLOR
-}
-
-/** Current theme (light unless the user explicitly toggled to dark). */
-export function getMobileTheme(): MobileTheme {
-  return current
-}
-
-/** Subscribe to theme changes; returns the unsubscribe function. */
-export function subscribeMobileTheme(listener: () => void): () => void {
-  listeners.add(listener)
-  return () => { listeners.delete(listener) }
-}
-
-/** Set the theme explicitly (persisted + applied to the document). */
-export function setMobileTheme(theme: MobileTheme): void {
-  if (theme === current) return
-  current = theme
-  persist(theme)
-  applyToDocument(theme)
-  for (const listener of [...listeners]) listener()
-}
-
-/** Flip light/dark and return the new theme. */
-export function toggleMobileTheme(): MobileTheme {
-  setMobileTheme(current === 'light' ? 'dark' : 'light')
-  return current
-}
-
-/** Apply the persisted (or default) theme once at boot, before first paint. */
-export function initMobileTheme(): void {
-  applyToDocument(current)
-}

package/src/mobile/mux.test.ts

@@ -1,314 +0,0 @@
-/** mux: live-event client, SSE delivery + stall-driven polling fallback. */
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { MuxClient, type EventSourceLike } from './mux.ts'
-import type { HistoryPage } from './api.ts'
-
-/** A recorded fake EventSource (delivery driven by the test). */
-interface FakeSource extends EventSourceLike {
-  url: string
-  closed: boolean
-  close: () => void
-}
-
-/** Create an EventSource factory that records every opened source. */
-function makeSources(): { factory: (url: string) => EventSourceLike; sources: FakeSource[] } {
-  const sources: FakeSource[] = []
-  const factory = (url: string): EventSourceLike => {
-    const source: FakeSource = {
-      url,
-      onmessage: null,
-      onerror: null,
-      closed: false,
-      close: () => { source.closed = true },
-    }
-    sources.push(source)
-    return source
-  }
-  return { factory, sources }
-}
-
-/** One history page whose events carry sequential ids. */
-function pageOf(seqs: readonly number[]): HistoryPage {
-  return {
-    hasMore: false,
-    events: seqs.map(seq => ({
-      event: { type: 'user/message', seq, time: seq * 1_000, data: { text: String(seq) } },
-    })),
-  } as unknown as HistoryPage
-}
-
-/** A server-request envelope carrying one mux frame (the SSE wire shape). */
-function envelopeWith(payload: unknown): string {
-  return JSON.stringify({ type: 'server-request', rpcId: 'r1', method: 'events.mux', payload })
-}
-
-/** Options common to every test: tight clocks, injected data source. */
-function baseOptions(pollLatest: (sessionId: string) => Promise<HistoryPage>, factory: (url: string) => EventSourceLike) {
-  return { sourceFactory: factory, pollLatest, stallThresholdMs: 800, pollIntervalMs: 400 }
-}
-
-describe('MuxClient polling fallback', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-  })
-
-  it('does not poll while the SSE channel is fresh', async () => {
-    const { factory } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([0]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    const frames: unknown[] = []
-    client.onFrame(frame => { frames.push(frame) })
-    client.start()
-    client.observe('s1')
-    await vi.advanceTimersByTimeAsync(400) // well under the stall threshold
-    expect(pollLatest).not.toHaveBeenCalled()
-    expect(frames).toHaveLength(0)
-    client.stop()
-  })
-
-  it('starts polling after silence and emits appended events as session/event frames', async () => {
-    const { factory } = makeSources()
-    const pages = [pageOf([0]), pageOf([0, 1])]
-    const pollLatest = vi.fn(async (_sessionId: string) => pages.shift() ?? pageOf([]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    const frames: Array<{ type: string; sessionId: string; event?: { seq: number } }> = []
-    client.onFrame(frame => { frames.push(frame as never) })
-    client.start()
-    client.observe('s1')
-
-    // Nothing live within a poll interval until the stall window passes.
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).not.toHaveBeenCalled()
-
-    // The single tick (400 ms) crosses the 800 ms stall threshold at 1200 ms:
-    // the same tick then runs the first poll and emits seq 0.
-    await vi.advanceTimersByTimeAsync(800) // 1200ms total -> first stall crossing tick
-    expect(pollLatest).toHaveBeenCalledWith('s1')
-    expect(frames).toHaveLength(1)
-    expect(frames[0]).toMatchObject({ type: 'session/event', sessionId: 's1' })
-    expect(frames[0]?.event).toMatchObject({ seq: 0 })
-
-    // The next poll emits only the appended event (seq 1), not seq 0 again.
-    await vi.advanceTimersByTimeAsync(400)
-    expect(frames).toHaveLength(2)
-    expect(frames[1]?.event).toMatchObject({ seq: 1 })
-    client.stop()
-  })
-
-  it('sorts an out-of-order history page before advancing the watermark', async () => {
-    const { factory } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([2, 1, 3]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    const seqs: number[] = []
-    client.onFrame((frame) => {
-      if (frame.type === 'session/event' && typeof frame.event.seq === 'number') seqs.push(frame.event.seq)
-    })
-    client.start()
-    client.observe('s1')
-
-    await vi.advanceTimersByTimeAsync(1200)
-    expect(seqs).toEqual([1, 2, 3])
-    client.stop()
-  })
-
-  it('keeps the watermark so a repeated page never re-emits old events', async () => {
-    const { factory } = makeSources()
-    // Two calls return the same page: the second must emit nothing.
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([0, 1, 2]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    const frames: Array<{ type: string; event?: { seq: number } }> = []
-    client.onFrame(frame => { frames.push(frame as never) })
-    client.start()
-    client.observe('s1')
-
-    await vi.advanceTimersByTimeAsync(1200) // first poll -> 3 events
-    expect(frames).toHaveLength(3)
-
-    await vi.advanceTimersByTimeAsync(400) // second poll -> same page, nothing new
-    expect(frames).toHaveLength(3)
-    client.stop()
-  })
-
-  it('stops polling when observe is cleared and keeps it stopped', async () => {
-    const { factory } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([0]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    client.start()
-    client.observe('s1')
-
-    await vi.advanceTimersByTimeAsync(1200)
-    expect(pollLatest).toHaveBeenCalled()
-
-    client.observe(undefined)
-    const callsAfterClear = pollLatest.mock.calls.length
-    await vi.advanceTimersByTimeAsync(2000)
-    expect(pollLatest.mock.calls.length).toBe(callsAfterClear)
-    client.stop()
-  })
-
-  it('stops polling on stop(), closing any live source', async () => {
-    const { factory, sources } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([0]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    client.start()
-    client.observe('s1')
-
-    await vi.advanceTimersByTimeAsync(1200)
-    expect(pollLatest).toHaveBeenCalled()
-
-    client.stop()
-    const callsAfterStop = pollLatest.mock.calls.length
-    await vi.advanceTimersByTimeAsync(2000)
-    expect(pollLatest.mock.calls.length).toBe(callsAfterStop)
-    expect(sources[0]?.closed).toBe(true)
-  })
-
-  it('returns to SSE when a frame arrives, dropping the fallback poller', async () => {
-    const { factory, sources } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([0]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    const frames: unknown[] = []
-    client.onFrame(frame => { frames.push(frame) })
-    client.start()
-    client.observe('s1')
-
-    // Stall into polling.
-    await vi.advanceTimersByTimeAsync(1200)
-    expect(pollLatest).toHaveBeenCalledTimes(1)
-
-    // A live mux frame proves SSE delivers again -> fallback stops.
-    sources[0]?.onmessage?.({ data: envelopeWith({ type: 'session/subscribed', sessionId: 's1', lastSeq: 4 }) })
-
-    await vi.advanceTimersByTimeAsync(2000)
-    expect(pollLatest.mock.calls.length).toBe(1) // polling stopped after the live frame
-    const live = frames.filter(frame => (frame as { type?: string })?.type === 'session/subscribed')
-    expect(live).toHaveLength(1)
-    expect(live[0]).toMatchObject({ type: 'session/subscribed', sessionId: 's1' })
-    client.stop()
-  })
-
-  it('recovers when a previously-live SSE stream becomes silently stalled', async () => {
-    const { factory, sources } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([5]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    const frames: Array<{ type: string; event?: { seq: number } }> = []
-    client.onFrame(frame => { frames.push(frame as never) })
-    client.start()
-    client.observe('s1')
-
-    sources[0]?.onmessage?.({ data: envelopeWith({ type: 'session/subscribed', sessionId: 's1', lastSeq: 4 }) })
-    await vi.advanceTimersByTimeAsync(2400)
-    expect(pollLatest).not.toHaveBeenCalled()
-
-    // A once-live stream gets three stall windows; the next scheduler tick
-    // crosses that boundary and starts the ordinary-HTTP recovery path.
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(1)
-    expect(frames.at(-1)?.event).toMatchObject({ seq: 5 })
-    client.stop()
-  })
-
-  it('backs empty polls off and resets to the base cadence after progress', async () => {
-    const { factory } = makeSources()
-    const pages = [pageOf([]), pageOf([1]), pageOf([1, 2])]
-    const pollLatest = vi.fn(async (_sessionId: string) => pages.shift() ?? pageOf([]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    client.start()
-    client.observe('s1')
-
-    await vi.advanceTimersByTimeAsync(1200)
-    expect(pollLatest).toHaveBeenCalledTimes(1)
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(1)
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(2)
-
-    // The productive second poll resets the next delay from 800 ms to 400 ms.
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(3)
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(4)
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(4)
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(5)
-    client.stop()
-  })
-
-  it('drives the whole lifecycle on a single scheduler tick (one interval)', async () => {
-    const { factory } = makeSources()
-    const setIntervalSpy = vi.spyOn(globalThis, 'setInterval')
-    try {
-      const pages = [pageOf([0]), pageOf([0, 1])]
-      const pollLatest = vi.fn(async (_sessionId: string) => pages.shift() ?? pageOf([]))
-      const client = new MuxClient('/m/api/events.mux', {
-        sourceFactory: factory,
-        pollLatest,
-        stallThresholdMs: 1500,
-        pollIntervalMs: 2000,
-      })
-      client.start()
-      client.observe('s1')
-
-      // Exactly one interval is ever created: the single tick scheduler.
-      expect(setIntervalSpy).toHaveBeenCalledTimes(1)
-
-      // The tick fires below the stall threshold without polling.
-      await vi.advanceTimersByTimeAsync(1000)
-      expect(pollLatest).not.toHaveBeenCalled()
-
-      // The same interval arms the fallback once silence passes the threshold
-      // (tick at 2000 crosses 1500) and runs the first poll immediately.
-      await vi.advanceTimersByTimeAsync(1100) // 2100ms total
-      expect(pollLatest).toHaveBeenCalledTimes(1)
-      expect(setIntervalSpy).toHaveBeenCalledTimes(1) // still one timer
-
-      // Subsequent polls ride the same tick at the poll cadence (2000 ms).
-      await vi.advanceTimersByTimeAsync(2000)
-      expect(pollLatest).toHaveBeenCalledTimes(2)
-      client.stop()
-    } finally {
-      setIntervalSpy.mockRestore()
-    }
-  })
-
-  it('paces polls on the tick only after the stall phase ends', async () => {
-    const { factory } = makeSources()
-    const pages = [pageOf([0]), pageOf([0, 1]), pageOf([0, 1, 2]), pageOf([0, 1, 2, 3])]
-    const pollLatest = vi.fn(async (_sessionId: string) => pages.shift() ?? pageOf([]))
-    const client = new MuxClient('/m/api/events.mux', {
-      sourceFactory: factory,
-      pollLatest,
-      stallThresholdMs: 800,
-      pollIntervalMs: 400,
-    })
-    client.start()
-    client.observe('s1')
-
-    // At 1200 ms the stall threshold is crossed on this single 400 ms tick.
-    await vi.advanceTimersByTimeAsync(1200)
-    expect(pollLatest).toHaveBeenCalledTimes(1)
-
-    // Each subsequent 400 ms tick is a poll, matching the poll cadence.
-    await vi.advanceTimersByTimeAsync(400)
-    await vi.advanceTimersByTimeAsync(400)
-    await vi.advanceTimersByTimeAsync(400)
-    expect(pollLatest).toHaveBeenCalledTimes(4)
-    client.stop()
-  })
-
-  it('observe() already in the stall window starts the single-tick poller immediately', async () => {
-    const { factory } = makeSources()
-    const pollLatest = vi.fn(async (_sessionId: string) => pageOf([0]))
-    const client = new MuxClient('/m/api/events.mux', baseOptions(pollLatest, factory))
-    client.start()
-    // Advance well past the stall threshold while nothing is observed.
-    await vi.advanceTimersByTimeAsync(2000)
-    expect(pollLatest).not.toHaveBeenCalled()
-
-    // Observing a session now is already in the stall window: poll right away.
-    client.observe('s1')
-    expect(pollLatest).toHaveBeenCalledTimes(1)
-    client.stop()
-  })
-})