@talex-touch/utils 1.0.30 → 1.0.32

package/plugin/sdk/window/index.ts

@@ -1,20 +1,22 @@
-import { genChannel } from '../../channel';
 import type {
-  BrowserWindowConstructorOptions,
   BrowserWindow,
+  BrowserWindowConstructorOptions,
   WebContents,
 } from 'electron'
+import { genChannel } from '../../channel'
 
 export function createWindow(options: BrowserWindowConstructorOptions & { file?: string } & { url?: string }): number {
   const res = genChannel().sendSync('window:new', options)
-  if (res.error) throw new Error(res.error)
+  if (res.error)
+    throw new Error(res.error)
 
   return res.id
 }
 
 export function toggleWinVisible(id: number, visible?: boolean): boolean {
   const res = genChannel().sendSync('window:visible', visible !== undefined ? { id, visible } : { id })
-  if (res.error) throw new Error(res.error)
+  if (res.error)
+    throw new Error(res.error)
 
   return res.visible
 }
@@ -23,7 +25,8 @@ export function setWindowProperty(id: number, property: {
 
 }): boolean {
   const res = genChannel().sendSync('window:property', { id, property })
-  if (res.error) throw new Error(res.error)
+  if (res.error)
+    throw new Error(res.error)
 
   return res.success
 }

package/preload/loading.ts

@@ -4,12 +4,12 @@ export type LoadingMode = 'classic' | 'progress' | 'debug'
 
 export type LoadingState = 'start' | 'finish'
 
-export type LoadingEvent =
-  | { type: 'mode'; mode: LoadingMode }
-  | { type: 'message'; message: string }
-  | { type: 'progress'; delta?: number; reset?: boolean }
-  | { type: 'state'; state: LoadingState }
+export type LoadingEvent
+  = | { type: 'mode', mode: LoadingMode }
+    | { type: 'message', message: string }
+    | { type: 'progress', delta?: number, reset?: boolean }
+    | { type: 'state', state: LoadingState }
 
 export interface PreloadAPI {
-  sendPreloadEvent(event: LoadingEvent): void
+  sendPreloadEvent: (event: LoadingEvent) => void
 }

package/preload/renderer.ts

@@ -1,7 +1,8 @@
 import type { LoadingEvent, LoadingMode, LoadingState, PreloadAPI } from './loading'
 
 function getPreloadApi(): PreloadAPI | null {
-  if (typeof window === 'undefined') return null
+  if (typeof window === 'undefined')
+    return null
   return (window as any).api ?? null
 }
 
@@ -36,6 +37,7 @@ export function preloadDebugStep(message: string, delta = 0.08): void {
 }
 
 export function preloadRemoveOverlay(): void {
-  if (typeof window === 'undefined') return
+  if (typeof window === 'undefined')
+    return
   window.postMessage({ payload: 'removeLoading' }, '*')
 }

package/renderer/hooks/arg-mapper.ts

@@ -1,4 +1,3 @@
-
 /**
  * Interface for command line argument mapper options
  * @interface IArgMapperOptions
@@ -33,7 +32,7 @@ declare global {
  * @returns Mapped command line arguments as key-value pairs
  */
 export function useArgMapper(args: string[] = process.argv): IArgMapperOptions {
-  if ( window.$argMapper ) {
+  if (window.$argMapper) {
     return window.$argMapper
   }
 

package/renderer/hooks/index.ts

@@ -1,3 +1,5 @@
 export * from './arg-mapper'
 export * from './initialize'
 export * from './performance'
+export * from './use-channel'
+export * from './use-intelligence'

package/renderer/hooks/initialize.ts

@@ -56,7 +56,8 @@ function checkWebGLSupport(): boolean {
   try {
     const canvas = document.createElement('canvas')
     return !!(canvas.getContext('webgl') || canvas.getContext('experimental-webgl'))
-  } catch {
+  }
+  catch {
     return false
   }
 }
@@ -69,7 +70,8 @@ function checkWebGL2Support(): boolean {
   try {
     const canvas = document.createElement('canvas')
     return !!canvas.getContext('webgl2')
-  } catch {
+  }
+  catch {
     return false
   }
 }
@@ -109,25 +111,25 @@ export function useInitialize(): IInitializationInfo {
     screenResolution: {
       width: screen.width,
       height: screen.height,
-      pixelRatio: window.devicePixelRatio || 1
+      pixelRatio: window.devicePixelRatio || 1,
     },
     windowSize: {
       innerWidth: window.innerWidth,
       innerHeight: window.innerHeight,
       outerWidth: window.outerWidth,
-      outerHeight: window.outerHeight
+      outerHeight: window.outerHeight,
     },
     performance: {
       navigationStart: performance.timeOrigin || now,
       loadEventEnd: (performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming)?.loadEventEnd || undefined,
-      domContentLoadedEventEnd: (performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming)?.domContentLoadedEventEnd || undefined
+      domContentLoadedEventEnd: (performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming)?.domContentLoadedEventEnd || undefined,
     },
     capabilities: {
       webgl: checkWebGLSupport(),
       webgl2: checkWebGL2Support(),
       webAudio: checkWebAudioSupport(),
-      serviceWorker: checkServiceWorkerSupport()
-    }
+      serviceWorker: checkServiceWorkerSupport(),
+    },
   }
 
   return window.$initInfo = initInfo
@@ -191,7 +193,7 @@ export function refreshPerformanceInfo(): IInitializationInfo {
     window.$initInfo.performance = {
       navigationStart: performance.timeOrigin || window.$initInfo.performance.navigationStart,
       loadEventEnd: navigationEntry?.loadEventEnd || undefined,
-      domContentLoadedEventEnd: navigationEntry?.domContentLoadedEventEnd || undefined
+      domContentLoadedEventEnd: navigationEntry?.domContentLoadedEventEnd || undefined,
     }
   }
   return window.$initInfo

package/renderer/hooks/performance.ts

@@ -41,7 +41,7 @@ export function getRendererPerformanceMetrics(): RendererPerformanceMetrics {
     loadEventEnd: navEntry?.loadEventEnd,
     domInteractive: navEntry?.domInteractive,
     firstPaint: firstPaint?.startTime,
-    firstContentfulPaint: firstContentfulPaint?.startTime
+    firstContentfulPaint: firstContentfulPaint?.startTime,
   }
 }
 
@@ -55,7 +55,8 @@ export function collectPerformanceMetricsOnLoad(): Promise<RendererPerformanceMe
       setTimeout(() => {
         resolve(getRendererPerformanceMetrics())
       }, 0)
-    } else {
+    }
+    else {
       // Wait for load event
       window.addEventListener('load', () => {
         setTimeout(() => {
@@ -81,7 +82,6 @@ export function getPerformanceSummary(): {
     domReady: metrics.domContentLoadedEventEnd || 0,
     pageLoad: metrics.loadEventEnd || 0,
     firstPaint: metrics.firstPaint,
-    firstContentfulPaint: metrics.firstContentfulPaint
+    firstContentfulPaint: metrics.firstContentfulPaint,
   }
 }
-

package/renderer/hooks/use-channel.ts

@@ -0,0 +1,150 @@
+import type { InjectionKey } from 'vue'
+import { inject } from 'vue'
+
+export interface TouchChannel {
+  send: <TRequest = any, TResponse = any>(
+    eventName: string,
+    data?: TRequest,
+  ) => Promise<TResponse>
+
+  regChannel?: <TRequest = any>(
+    eventName: string,
+    handler: (data: TRequest) => Promise<any> | any,
+  ) => () => void
+}
+
+// Injection key for the TouchChannel
+export const TouchChannelKey: InjectionKey<TouchChannel> = Symbol('TouchChannel')
+
+/**
+ * Global reference to the TouchChannel instance
+ * This is automatically injected by the main process
+ */
+declare global {
+  interface Window {
+    touchChannel?: TouchChannel
+    $touchChannel?: TouchChannel
+  }
+
+  var touchChannel: TouchChannel | undefined
+  var $touchChannel: TouchChannel | undefined
+}
+
+/**
+ * Resolve TouchChannel from multiple sources
+ */
+function resolveTouchChannel(): TouchChannel | null {
+  // Try dependency injection first
+  try {
+    const injectedChannel = inject(TouchChannelKey, null)
+    if (injectedChannel)
+      return injectedChannel
+  }
+  catch {
+    // Ignore injection errors outside of Vue context
+  }
+
+  // Try global variables
+  if (typeof globalThis !== 'undefined') {
+    const channel
+      = (globalThis as any).touchChannel
+        || (globalThis as any).$touchChannel
+        || (globalThis as any).window?.touchChannel
+        || (globalThis as any).window?.$touchChannel
+
+    if (channel)
+      return channel
+  }
+
+  // Try window object (browser environment)
+  if (typeof window !== 'undefined') {
+    const channel = window.touchChannel || window.$touchChannel
+    if (channel)
+      return channel
+  }
+
+  return null
+}
+
+/**
+ * Composable for using TouchChannel communication
+ *
+ * Provides a reactive interface to communicate with the main process
+ * through the TouchChannel IPC system. Works in both renderer and
+ * corebox contexts.
+ *
+ * @example
+ * ```ts
+ * const channel = useChannel()
+ *
+ * // Send a message to main process
+ * const result = await channel.send('get-app-config')
+ *
+ * // Send with data
+ * const saved = await channel.send('save-config', { theme: 'dark' })
+ *
+ * // Register a handler (if supported)
+ * const cleanup = channel.regChannel?.('config-updated', (data) => {
+ *   console.log('Config updated:', data)
+ * })
+ *
+ * // Cleanup handler when component unmounts
+ * onUnmounted(() => {
+ *   cleanup?.()
+ * })
+ * ```
+ */
+export function useChannel(): TouchChannel {
+  const channel = resolveTouchChannel()
+
+  if (!channel) {
+    throw new Error(
+      '[useChannel] TouchChannel not available. '
+      + 'Make sure the TouchChannel is properly injected by the main process.',
+    )
+  }
+
+  return channel
+}
+
+/**
+ * Helper composable that creates a typed channel wrapper
+ * for specific communication patterns
+ *
+ * @example
+ * ```ts
+ * interface ConfigAPI {
+ *   'get-config': { key: string } => { value: any }
+ *   'set-config': { key: string; value: any } => { success: boolean }
+ * }
+ *
+ * const configChannel = useTypedChannel<ConfigAPI>()
+ *
+ * // Type-safe usage
+ * const result = await configChannel.send('get-config', { key: 'theme' })
+ * // result is automatically typed as { value: any }
+ * ```
+ */
+export function useTypedChannel<TChannelMap extends Record<string, any>>() {
+  const channel = useChannel()
+
+  return {
+    send<TEventName extends keyof TChannelMap>(
+      eventName: TEventName,
+      ...args: TChannelMap[TEventName] extends (arg: infer TArg) => any
+        ? [TArg]
+        : []
+    ): Promise<
+      TChannelMap[TEventName] extends (arg: any) => infer TReturn
+        ? TReturn
+        : any
+    > {
+      return channel.send(
+        eventName as string,
+        args.length > 0 ? args[0] : undefined,
+      )
+    },
+
+    regChannel: channel.regChannel,
+  }
+}

package/renderer/hooks/use-intelligence.ts

@@ -0,0 +1,236 @@
+import type { Ref } from 'vue'
+import type {
+  AiChatPayload,
+  AiEmbeddingPayload,
+  AiInvokeOptions,
+  AiInvokeResult,
+  AiProviderConfig,
+  AiVisionOcrPayload,
+  AiVisionOcrResult,
+} from '../../types/intelligence'
+import { ref } from 'vue'
+import { useChannel } from './use-channel'
+
+interface UseIntelligenceOptions {
+  // Reserved for future options
+}
+
+interface IntelligenceComposable {
+  // Core invoke functions
+  invoke: <T = any>(
+    capabilityId: string,
+    payload: any,
+    options?: AiInvokeOptions,
+  ) => Promise<AiInvokeResult<T>>
+
+  // Provider testing
+  testProvider: (config: AiProviderConfig) => Promise<{
+    success: boolean
+    message: string
+    latency?: number
+    timestamp: number
+  }>
+
+  // Capability testing
+  testCapability: (params: {
+    capabilityId: string
+    providerId?: string
+    userInput?: string
+    source?: any
+  }) => Promise<{
+    ok: boolean
+    result: any
+  }>
+
+  // Get capability test metadata
+  getCapabilityTestMeta: (params: {
+    capabilityId: string
+  }) => Promise<{
+    requiresUserInput: boolean
+    inputHint: string
+  }>
+
+  // Convenient text methods
+  text: {
+    chat: (payload: AiChatPayload, options?: AiInvokeOptions) => Promise<AiInvokeResult<string>>
+    translate: (payload: { text: string, sourceLang?: string, targetLang: string }, options?: AiInvokeOptions) => Promise<AiInvokeResult<string>>
+    summarize: (payload: { text: string, maxLength?: number, style?: 'concise' | 'detailed' | 'bullet-points' }, options?: AiInvokeOptions) => Promise<AiInvokeResult<string>>
+  }
+
+  // Convenient embedding methods
+  embedding: {
+    generate: (payload: AiEmbeddingPayload, options?: AiInvokeOptions) => Promise<AiInvokeResult<number[]>>
+  }
+
+  // Convenient vision methods
+  vision: {
+    ocr: (payload: AiVisionOcrPayload, options?: AiInvokeOptions) => Promise<AiInvokeResult<AiVisionOcrResult>>
+  }
+
+  // Loading state
+  isLoading: Ref<boolean>
+  lastError: Ref<string | null>
+}
+
+/**
+ * Intelligence Composable for Vue components
+ *
+ * Provides a reactive interface to the Intelligence module through channel communication
+ *
+ * @example
+ * ```ts
+ * const { invoke, text, isLoading, lastError } = useIntelligence()
+ *
+ * // Basic invoke
+ * const result = await invoke('text.chat', {
+ *   messages: [{ role: 'user', content: 'Hello' }]
+ * })
+ *
+ * // Convenient text chat
+ * const chatResult = await text.chat({
+ *   messages: [{ role: 'user', content: 'Hello' }]
+ * })
+ *
+ * // With loading state
+ * watch(isLoading, (loading) => {
+ *   if (loading) console.log('AI request in progress...')
+ * })
+ * ```
+ */
+export function useIntelligence(_options: UseIntelligenceOptions = {}): IntelligenceComposable {
+  const isLoading = ref(false)
+  const lastError = ref<string | null>(null)
+
+  // Get the TouchChannel instance
+  const channel = useChannel()
+
+  // Helper for consistent response handling
+  interface ChannelResponse<T> {
+    ok: boolean
+    result?: T
+    error?: string
+  }
+
+  async function sendChannelRequest<T>(
+    eventName: string,
+    payload: any,
+  ): Promise<T> {
+    const response = await channel.send<any, ChannelResponse<T>>(eventName, payload)
+    if (!response?.ok) {
+      throw new Error(response?.error || 'Intelligence request failed')
+    }
+    return response.result as T
+  }
+
+  // Wrapper function that handles loading state and errors
+  async function withLoadingState<T>(operation: () => Promise<T>): Promise<T> {
+    isLoading.value = true
+    lastError.value = null
+
+    try {
+      const result = await operation()
+      return result
+    }
+    catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      lastError.value = errorMessage
+      throw error
+    }
+    finally {
+      isLoading.value = false
+    }
+  }
+
+  return {
+    // Core invoke
+    invoke: <T = any>(capabilityId: string, payload: any, options?: AiInvokeOptions) =>
+      withLoadingState(() =>
+        sendChannelRequest<AiInvokeResult<T>>('intelligence:invoke', { capabilityId, payload, options }),
+      ),
+
+    // Provider testing
+    testProvider: (config: AiProviderConfig) =>
+      withLoadingState(() =>
+        sendChannelRequest<{
+          success: boolean
+          message: string
+          latency?: number
+          timestamp: number
+        }>('intelligence:test-provider', { provider: config }),
+      ),
+
+    // Capability testing
+    testCapability: (params: { capabilityId: string, providerId?: string, userInput?: string, source?: any }) =>
+      withLoadingState(() =>
+        sendChannelRequest<{
+          ok: boolean
+          result: any
+        }>('intelligence:test-capability', params),
+      ),
+
+    // Get capability test metadata
+    getCapabilityTestMeta: (params: { capabilityId: string }) =>
+      sendChannelRequest<{
+        requiresUserInput: boolean
+        inputHint: string
+      }>('intelligence:get-capability-test-meta', params),
+
+    // Convenient text methods
+    text: {
+      chat: (payload: AiChatPayload, options?: AiInvokeOptions) =>
+        withLoadingState(() =>
+          sendChannelRequest<AiInvokeResult<string>>('intelligence:invoke', {
+            capabilityId: 'text.chat',
+            payload,
+            options,
+          }),
+        ),
+
+      translate: (payload: { text: string, sourceLang?: string, targetLang: string }, options?: AiInvokeOptions) =>
+        withLoadingState(() =>
+          sendChannelRequest<AiInvokeResult<string>>('intelligence:invoke', {
+            capabilityId: 'text.translate',
+            payload,
+            options,
+          }),
+        ),
+
+      summarize: (payload: { text: string, maxLength?: number, style?: 'concise' | 'detailed' | 'bullet-points' }, options?: AiInvokeOptions) =>
+        withLoadingState(() =>
+          sendChannelRequest<AiInvokeResult<string>>('intelligence:invoke', {
+            capabilityId: 'text.summarize',
+            payload,
+            options,
+          }),
+        ),
+    },
+
+    // Convenient embedding methods
+    embedding: {
+      generate: (payload: AiEmbeddingPayload, options?: AiInvokeOptions) =>
+        withLoadingState(() =>
+          sendChannelRequest<AiInvokeResult<number[]>>('intelligence:invoke', {
+            capabilityId: 'embedding.generate',
+            payload,
+            options,
+          }),
+        ),
+    },
+
+    // Convenient vision methods
+    vision: {
+      ocr: (payload: AiVisionOcrPayload, options?: AiInvokeOptions) =>
+        withLoadingState(() =>
+          sendChannelRequest<AiInvokeResult<AiVisionOcrResult>>('intelligence:invoke', {
+            capabilityId: 'vision.ocr',
+            payload,
+            options,
+          }),
+        ),
+    },
+
+    // Reactive state
+    isLoading,
+    lastError,
+  }
+}

package/renderer/index.ts

@@ -1,5 +1,10 @@
+export * from '../auth'
+export * from '../intelligence/client'
+// Re-export Intelligence types (client-side only)
+export * from '../types/intelligence'
+export * from './hooks'
 export * from './ref'
 export * from './storage'
+
 export * from './touch-sdk'
 export * from './touch-sdk/utils'
-export * from './hooks'

package/renderer/ref.ts

@@ -2,54 +2,50 @@ import { computed, customRef } from 'vue'
 
 export function useModelWrapper(props: any, emit: any, name = 'modelValue') {
   return computed({
-      get: () => props[name],
-      set: (value) => emit(`update:${name}`, value)
+    get: () => props[name],
+    set: value => emit(`update:${name}`, value),
   })
 }
 
 export function throttleRef(value: any, time: number) {
-
   let ts = 0
 
   return customRef((track, trigger) => {
-      return {
-          get() {
-              track()
-              return value
-          },
-          set(newValue) {
-
-              if( new Date().getTime() - ts < time ) return
-
-              value = newValue
-              track()
-              trigger()
-              ts = new Date().getTime()
-          }
-      }
+    return {
+      get() {
+        track()
+        return value
+      },
+      set(newValue) {
+        if (new Date().getTime() - ts < time)
+          return
+
+        value = newValue
+        track()
+        trigger()
+        ts = new Date().getTime()
+      },
+    }
   })
-
 }
 
 export function debounceRef(value: any, delay: number) {
-
   let timer: any
 
   return customRef((track, trigger) => {
-      return {
-          get() {
-              track()
-              return value
-          },
-          set(newValue) {
-              clearTimeout(timer)
-              timer = setTimeout(() => {
-                  value = newValue
-                  track()
-                  trigger()
-              }, delay)
-          }
-      }
+    return {
+      get() {
+        track()
+        return value
+      },
+      set(newValue) {
+        clearTimeout(timer)
+        timer = setTimeout(() => {
+          value = newValue
+          track()
+          trigger()
+        }, delay)
+      },
+    }
   })
-
-}
+}