@quidgest/chatbot 0.5.1 → 0.5.3-dev.0

package/src/composables/useSSE.ts

@@ -1,93 +1,92 @@
 import axios, { AxiosRequestConfig } from 'axios'
 
-type SSEvents = {
-    onMessage?: (message: string) => void
-    onError?: (error: Error) => void
-    onFieldMetadata?: (metadata: Record<string, unknown>) => void
-    onDone?: () => void
+export type SSEvents = {
+	onMessage?: (message: string) => void
+	onError?: (error: Error) => void
+	onFieldMetadata?: (metadata: Record<string, unknown>) => void
+	onDone?: () => void
 }
 
 export async function useSSE(config: AxiosRequestConfig, handlers: SSEvents) {
-    const controller = new AbortController()
-    const signal = controller.signal
+	const controller = new AbortController()
+	const signal = controller.signal
 
-    const response = await axios({
-        ...config,
-        headers: {
-            Accept: 'text/event-stream'
-        },
-        responseType: 'stream',
-        signal,
-        adapter: 'fetch'
-    })
+	const response = await axios({
+		...config,
+		headers: {
+			Accept: 'text/event-stream'
+		},
+		responseType: 'stream',
+		signal,
+		adapter: 'fetch'
+	})
 
-    const stream = response.data
+	const stream = response.data
 
-    if (!stream || !(stream instanceof ReadableStream)) {
-        throw new Error('Invalid stream response')
-    }
+	if (!stream || !(stream instanceof ReadableStream)) {
+		throw new Error('Invalid stream response')
+	}
 
-    const reader = stream.getReader()
-    const decoder = new TextDecoder()
+	const reader = stream.getReader()
+	const decoder = new TextDecoder()
 
-    while (true) {
-        const { done, value } = await reader.read()
-        if (done) {
-            handlers.onDone?.()
-            break
-        }
+	while (true) {
+		const { done, value } = await reader.read()
+		if (done) {
+			handlers.onDone?.()
+			break
+		}
 
-        const chunk = decoder.decode(value, { stream: true })
-        const events = chunk.split(/\n\n+/)
+		const chunk = decoder.decode(value, { stream: true })
+		const events = chunk.split(/\n\n+/)
 
-        for (const eventBlock of events) {
-            const lines = eventBlock.trim().split('\n')
-            let name = ''
-            let data = ''
+		for (const eventBlock of events) {
+			const lines = eventBlock.trim().split('\n')
+			let name = ''
+			let data = ''
 
-            for (const line of lines) {
-                if (line.startsWith('event:')) {
-                    name = line.replace('event:', '').trim()
-                } else if (line.startsWith('data:')) {
-                    data = line.replace('data:', '').trim()
-                }
-            }
+			for (const line of lines) {
+				if (line.startsWith('event:')) {
+					name = line.replace('event:', '').trim()
+				} else if (line.startsWith('data:')) {
+					data = line.replace('data:', '').trim()
+				}
+			}
 
+			// Backward compatibility for missing event names
+			if (!name) name = 'message'
 
-            // Backward compatibility for missing event names
-            if(!name) name = 'message';
+			if (!data) continue
 
-            if (!data) continue
-
-            try {
-                const parsedData = JSON.parse(data)
-                switch (name) {
-                    case 'message':
-                        handlers.onMessage?.(parsedData.value)
-                        break
-                    case 'error':
-                        handlers.onError?.(new Error(parsedData.value))
-                        break
-                    case 'field_metadata':
-                        handlers.onFieldMetadata?.(parsedData)
-                        break
-                    case 'done':
-                        handlers.onDone?.()
-                        break
-                    default:
-                        console.warn(`Unknown event type: ${name}`)
-                }
-            } catch (error) {
-                handlers.onError?.(error as Error)
-                console.error('Error processing event:', error)
-                continue
-            } finally {
-                // Ensure we always clean up the reader
-                if (done) {
-                    reader.releaseLock()
-                    controller.abort()
-                }
-            }
-        }
-    }
+			try {
+				const parsedData = JSON.parse(data)
+				switch (name) {
+					case 'message':
+						handlers.onMessage?.(parsedData.value)
+						break
+					case 'error':
+						handlers.onError?.(new Error(parsedData.value))
+						break
+					case 'field_metadata':
+						handlers.onFieldMetadata?.(parsedData)
+						break
+					case 'done':
+						handlers.onDone?.()
+						break
+					default:
+						console.warn(`Unknown event type: ${name}`)
+				}
+			} catch (error) {
+				handlers.onError?.(error as Error)
+				console.error('Error processing event:', error)
+				continue
+			} finally {
+				// Ensure we always clean up the reader
+				if (done) {
+					reader.releaseLock()
+					controller.abort()
+				}
+			}
+		}
+	}
 }

package/src/composables/useTexts.ts

@@ -1,32 +1,35 @@
+/**
+ * TODO: Implement localization
+ */
 export function useTexts() {
-    return {
-        copy: 'Copy',
-        apply: 'Apply',
-        applyAll: 'Apply all',
-        chatbotTitle: 'ChatBot',
-        sendMessage: 'Send message',
-        clearChat: 'Clear chat',
-        inputLabel: 'What can I help with?',
-        imageUpload: 'Upload Image',
-        imageUploadQButton: 'Upload Image',
-        goodResponse: 'Good response',
-        badResponse: 'Bad response',
-        initialMessage:
-            "Howdy! I am GenioBot 👋, Quidgest's personal AI assistant! How can I help you?",
-        initialAgentMessage:
-            'Just a temporary message while we are working on the agent mode',
-        loginError:
-            'Uh oh, I could not authenticate with the Quidgest API endpoint 😓',
-        botIsSick:
-            '*cough cough* GenioBot is not feeling alright 🥴️🤒, looks like something failed!',
-        commentDialogTitle: 'Would you like to add a comment?',
-        commentPlaceholder: 'Type your comment here (optional)...',
-        copyResponse: 'Copy response',
-        submitButton: 'Submit',
-        cancelButton: 'Cancel',
-        senderImage: 'Sender Image',
-        imagePreview: 'Image preview',
-        regenerateResponse: 'Regenerate response',
-        generatingResponse: 'Generating'
-    }
+	return {
+		copy: 'Copy',
+		apply: 'Apply',
+		applyAll: 'Apply all',
+		chatbotTitle: 'ChatBot',
+		sendMessage: 'Send message',
+		clearChat: 'Clear chat',
+		inputLabel: 'What can I help with?',
+		imageUpload: 'Upload Image',
+		imageUploadQButton: 'Upload Image',
+		goodResponse: 'Good response',
+		badResponse: 'Bad response',
+		initialMessage:
+			"Howdy! I am GenioBot 👋, Quidgest's personal AI assistant! How can I help you?",
+		initialAgentMessage: 'Just a temporary message while we are working on the agent mode',
+		loginError: 'Uh oh, I could not authenticate with the Quidgest API endpoint 😓',
+		botIsSick:
+			'*cough cough* GenioBot is not feeling alright 🥴️🤒, looks like something failed!',
+		commentDialogTitle: 'Would you like to add a comment?',
+		commentPlaceholder: 'Type your comment here (optional)...',
+		copyResponse: 'Copy response',
+		submitButton: 'Submit',
+		cancelButton: 'Cancel',
+		senderImage: 'Sender Image',
+		imagePreview: 'Image preview',
+		regenerateResponsePrompt: 'Regenerate a new response for field {0}',
+		regenerateResponse: 'Regenerate response',
+		generatingResponse: 'Generating',
+		suggestionsForField: 'Suggestions for field'
+	}
 }

package/src/test/setup.ts

@@ -0,0 +1,41 @@
+import { vi } from 'vitest'
+import { config } from '@vue/test-utils'
+
+import { createFramework } from '@quidgest/ui/framework'
+import { QSelect } from '@quidgest/ui/components'
+
+vi.mock('@quidgest/ui/components', async (importOriginal) => {
+	const original = await importOriginal<typeof import('@quidgest/ui/components')>()
+	return {
+		...original,
+		// QIcon needs to be mocked to prevent it from making network requests for icons during tests
+		QIcon: {
+			name: 'QIcon',
+			props: ['icon'],
+			template: '<span :data-test="icon"><slot /></span>'
+		}
+	}
+})
+
+// Prevent any real network fetches (icons/assets) during tests
+// safe noop that resolves to a minimal response-like object
+globalThis.fetch = vi.fn().mockResolvedValue({
+	ok: true,
+	arrayBuffer: async () => new ArrayBuffer(0),
+	blob: async () => new Blob(),
+	text: async () => ''
+} as unknown)
+
+const framework = createFramework()
+
+config.global.plugins = [
+	{
+		install(app) {
+			app.use(framework)
+		}
+	}
+]
+
+config.global.components = {
+	QSelect
+}

package/src/utils/__tests__/parseFieldValue.spec.ts

@@ -0,0 +1,27 @@
+import { parseFieldValue } from '../parseFieldValue'
+
+import { describe, it, expect } from 'vitest'
+
+describe('parseFieldValue', () => {
+	it('parses date strings correctly', () => {
+		const date = '2025-09-04'
+		const result = parseFieldValue('date', date)
+		expect(result).toBe(new Date(date).toLocaleDateString())
+	})
+
+	it('parses number strings correctly', () => {
+		const result = parseFieldValue('number', '123.45')
+		expect(result).toBe(123.45)
+	})
+
+	it('parses boolean strings correctly', () => {
+		expect(parseFieldValue('boolean', 'true')).toBe(true)
+		expect(parseFieldValue('boolean', 'false')).toBe(false)
+		expect(parseFieldValue('boolean', 'TRUE')).toBe(true)
+		expect(parseFieldValue('boolean', 'FALSE')).toBe(false)
+	})
+
+	it('returns text as string for unknown types', () => {
+		expect(parseFieldValue('unknown', '123')).toBe('123')
+	})
+})

package/src/utils/parseFieldValue.ts

@@ -0,0 +1,12 @@
+export function parseFieldValue(type: string, text: string) {
+	switch (type) {
+		case 'date':
+			return new Date(text).toLocaleDateString()
+		case 'number':
+			return parseFloat(text)
+		case 'boolean':
+			return text.toLowerCase() === 'true'
+		default:
+			return text.toString()
+	}
+}

package/src/utils/helper.ts

@@ -1,12 +0,0 @@
-export function parseFieldValue(type: string, text: string) {
-    switch (type) {
-        case 'date':
-            return new Date(text).toLocaleDateString()
-        case 'number':
-            return parseFloat(text)
-        case 'boolean':
-            return text.toLowerCase() === 'true'
-        default:
-            return text.toString()
-    }
-}