17380292065

Committed 01 Sep 2025 02:18PM UTC coverage: 63.442% (-5.4%) from 68.885%

Build # 17380292065

Build Type

push

github

Committed by

cgreening

Commit Message

Export data

Run Details

407 of 517 branches covered (78.72%)

Branch coverage included in aggregate %.

22 of 23 new or added lines in 3 files covered. (95.65%)

142 existing lines in 4 files now uncovered.

1941 of 3184 relevant lines covered (60.96%)

36.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.34

/src/hooks/useDataConnection.ts

import { useCallback, useState, useEffect } from 'react'
import { useSerial } from './useSerial'
import { useSignalGenerator, type GeneratorConfig } from './useSignalGenerator'

export interface SerialConfig {
  baudRate: number
  dataBits: 5 | 6 | 7 | 8
  stopBits: 1 | 2
  parity: 'none' | 'even' | 'odd'
  flowControl: 'none' | 'hardware'
}

export type ConnectionType = 'serial' | 'generator'

export interface ConnectionState {
  type: ConnectionType | null
  isConnecting: boolean
  isConnected: boolean
  isSupported: boolean
  error: string | null
}

export interface UseDataConnection {
  state: ConnectionState
  connectSerial: (config: SerialConfig) => Promise<void>
  connectGenerator: (config: GeneratorConfig) => Promise<void>
  disconnect: () => Promise<void>
  write: (data: string) => Promise<void>
  generatorConfig: GeneratorConfig
  setGeneratorConfig: (config: Partial<GeneratorConfig>) => void
}

const DEFAULT_SERIAL_CONFIG: SerialConfig = {
  baudRate: 115200,
  dataBits: 8,
  stopBits: 1,
  parity: 'none',
  flowControl: 'none'
}

export function useDataConnection(onLine: (line: string) => void): UseDataConnection {
  const [connectionType, setConnectionType] = useState<ConnectionType | null>(null)
  const [isConnecting, setIsConnecting] = useState(false)
  const [error, setError] = useState<string | null>(null)


  const serial = useSerial()
  const generator = useSignalGenerator(onLine)

  const state: ConnectionState = {
    type: connectionType,
    isConnecting: isConnecting || serial.state.isConnecting,
    isConnected: serial.state.isConnected || generator.isRunning,
    isSupported: serial.state.isSupported,
    error: error || serial.state.error
  }


  const connectSerial = useCallback(async (config: SerialConfig) => {
    if (generator.isRunning) {
      generator.stop()
    }
    
    setIsConnecting(true)
    setError(null)
    
    try {
      // Convert our config to the format useSerial expects
      // Note: Web Serial API has limited configuration options
      await serial.connect(config.baudRate)
      setConnectionType('serial')
      // The actual port configuration would need to be done at the port.open() level
      // For now, we'll just use baudRate as useSerial currently does
    } catch (err) {
      const message = err instanceof Error ? err.message : 'Failed to connect to serial port'
      setError(message)
      setConnectionType(null)
      throw err // Re-throw so ConnectModal knows the connection failed
    } finally {
      setIsConnecting(false)
    }
  }, [serial, generator])

  const connectGenerator = useCallback(async (config: GeneratorConfig) => {
    if (serial.state.isConnected) {
      await serial.disconnect()
    }
    
    setError(null)
    setConnectionType('generator')
    
    try {
      generator.setConfig(config)
      generator.start()
    } catch (err) {
      const message = err instanceof Error ? err.message : 'Failed to start signal generator'
      setError(message)
      setConnectionType(null)
    }
  }, [serial, generator])

  const disconnect = useCallback(async () => {
    setError(null)
    
    if (serial.state.isConnected) {
      await serial.disconnect()
    }
    
    if (generator.isRunning) {
      generator.stop()
    }
    
    setConnectionType(null)
  }, [serial, generator])

  // Set up serial line handler
  useEffect(() => {
    serial.onLine(onLine)
  }, [serial, onLine])

  const write = useCallback(async (data: string) => {
    if (connectionType !== 'serial' || !serial.state.isConnected) {
      throw new Error('Serial port not connected')
    }
    await serial.write(data)
  }, [connectionType, serial])

  return {
    state,
    connectSerial,
    connectGenerator,
    disconnect,
    write,
    generatorConfig: generator.config,
    setGeneratorConfig: generator.setConfig
  }
}

export { DEFAULT_SERIAL_CONFIG }

1	import { useCallback, useState, useEffect } from 'react'	1✔
2	import { useSerial } from './useSerial'
3	import { useSignalGenerator, type GeneratorConfig } from './useSignalGenerator'
4
5	export interface SerialConfig {
6	baudRate: number
7	dataBits: 5 \| 6 \| 7 \| 8
8	stopBits: 1 \| 2
9	parity: 'none' \| 'even' \| 'odd'
10	flowControl: 'none' \| 'hardware'
11	}
12
13	export type ConnectionType = 'serial' \| 'generator'
14
15	export interface ConnectionState {
16	type: ConnectionType \| null
17	isConnecting: boolean
18	isConnected: boolean
19	isSupported: boolean
20	error: string \| null
21	}
22
23	export interface UseDataConnection {
24	state: ConnectionState
25	connectSerial: (config: SerialConfig) => Promise<void>
26	connectGenerator: (config: GeneratorConfig) => Promise<void>
27	disconnect: () => Promise<void>
28	write: (data: string) => Promise<void>
29	generatorConfig: GeneratorConfig
30	setGeneratorConfig: (config: Partial<GeneratorConfig>) => void
31	}
32
33	const DEFAULT_SERIAL_CONFIG: SerialConfig = {	1✔
34	baudRate: 115200,	1✔
35	dataBits: 8,	1✔
36	stopBits: 1,	1✔
37	parity: 'none',	1✔
38	flowControl: 'none'	1✔
39	}	1✔
40
41	export function useDataConnection(onLine: (line: string) => void): UseDataConnection {	1✔
42	const [connectionType, setConnectionType] = useState<ConnectionType \| null>(null)	6✔
43	const [isConnecting, setIsConnecting] = useState(false)	6✔
44	const [error, setError] = useState<string \| null>(null)	6✔
45
46
47	const serial = useSerial()	6✔
48	const generator = useSignalGenerator(onLine)	6✔
49
50	const state: ConnectionState = {	6✔
51	type: connectionType,	6✔
52	isConnecting: isConnecting \|\| serial.state.isConnecting,	6✔
53	isConnected: serial.state.isConnected \|\| generator.isRunning,	6✔
54	isSupported: serial.state.isSupported,	6✔
55	error: error \|\| serial.state.error	6✔
56	}	6✔
57
58
59	const connectSerial = useCallback(async (config: SerialConfig) => {	6✔
60	if (generator.isRunning) {	2!
61	generator.stop()	×
UNCOV 62	}	×
63
64	setIsConnecting(true)	2✔
65	setError(null)	2✔
66
67	try {	2✔
68	// Convert our config to the format useSerial expects
69	// Note: Web Serial API has limited configuration options
70	await serial.connect(config.baudRate)	2✔
71	setConnectionType('serial')	2✔
72	// The actual port configuration would need to be done at the port.open() level
73	// For now, we'll just use baudRate as useSerial currently does
74	} catch (err) {	2!
75	const message = err instanceof Error ? err.message : 'Failed to connect to serial port'	×
76	setError(message)	×
77	setConnectionType(null)	×
UNCOV 78	throw err // Re-throw so ConnectModal knows the connection failed	×
79	} finally {	2✔
80	setIsConnecting(false)	2✔
81	}	2✔
82	}, [serial, generator])	6✔
83
84	const connectGenerator = useCallback(async (config: GeneratorConfig) => {	6✔
85	if (serial.state.isConnected) {	1!
86	await serial.disconnect()	×
UNCOV 87	}	×
88
89	setError(null)	1✔
90	setConnectionType('generator')	1✔
91
92	try {	1✔
93	generator.setConfig(config)	1✔
94	generator.start()	1✔
95	} catch (err) {	1!
96	const message = err instanceof Error ? err.message : 'Failed to start signal generator'	×
97	setError(message)	×
98	setConnectionType(null)	×
UNCOV 99	}	×
100	}, [serial, generator])	6✔
101
102	const disconnect = useCallback(async () => {	6✔
103	setError(null)	1✔
104
105	if (serial.state.isConnected) {	1!
106	await serial.disconnect()	×
UNCOV 107	}	×
108
109	if (generator.isRunning) {	1!
110	generator.stop()	×
UNCOV 111	}	×
112
113	setConnectionType(null)	1✔
114	}, [serial, generator])	6✔
115
116	// Set up serial line handler
117	useEffect(() => {	6✔
118	serial.onLine(onLine)	6✔
119	}, [serial, onLine])	6✔
120
121	const write = useCallback(async (data: string) => {	6✔
UNCOV 122	if (connectionType !== 'serial' \|\| !serial.state.isConnected) {	×
UNCOV 123	throw new Error('Serial port not connected')	×
UNCOV 124	}	×
UNCOV 125	await serial.write(data)	×
126	}, [connectionType, serial])	6✔
127
128	return {	6✔
129	state,	6✔
130	connectSerial,	6✔
131	connectGenerator,	6✔
132	disconnect,	6✔
133	write,	6✔
134	generatorConfig: generator.config,	6✔
135	setGeneratorConfig: generator.setConfig	6✔
136	}	6✔
137	}	6✔
138
139	export { DEFAULT_SERIAL_CONFIG }

atomic14 / web-serial-plotter / 17380292065

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous