@talex-touch/utils 1.0.40 → 1.0.44

package/renderer/touch-sdk/index.ts

@@ -1,7 +1,32 @@
 import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { ITuffTransport, TuffEvent } from '@talex-touch/utils/transport'
+import { defineRawEvent } from '@talex-touch/utils/transport/event/builder'
+
+const legacyCloseEvent = defineRawEvent<void, void>('close')
+const legacyHideEvent = defineRawEvent<void, void>('hide')
+const legacyMinimizeEvent = defineRawEvent<void, void>('minimize')
+const legacyDevToolsEvent = defineRawEvent<void, void>('dev-tools')
+const legacyCwdEvent = defineRawEvent<void, string>('common:cwd')
+const legacyPackageEvent = defineRawEvent<void, any>('get-package')
+const legacyOsEvent = defineRawEvent<void, any>('get-os')
+const legacyFolderOpenEvent = defineRawEvent<FolderOpenOptions, void>('folder:open')
+const legacyExecuteCmdEvent = defineRawEvent<ExecuteCommandOptions, void>('execute:cmd')
+const legacyAppOpenEvent = defineRawEvent<AppOpenOptions, void>('app:open')
+const legacyOpenExternalEvent = defineRawEvent<ExternalUrlOptions, void>('open-external')
+const legacyTempFileCreateEvent = defineRawEvent<TempFileCreateOptions, TempFileCreateResult>(
+  'temp-file:create',
+)
+const legacyTempFileDeleteEvent = defineRawEvent<TempFileDeleteOptions, TempFileDeleteResult>(
+  'temp-file:delete',
+)
+const legacyPluginFolderEvent = defineRawEvent<string, void>('plugin:explorer')
+const legacyPluginDevToolsEvent = defineRawEvent<string, void>('plugin:open-devtools')
+const legacyPluginReloadEvent = defineRawEvent<{ name: string }, void>('reload-plugin')
+const legacyModuleFolderEvent = defineRawEvent<{ name?: string }, void>('module:folder')
 
 export interface TouchSDKOptions {
-  channel: ITouchClientChannel
+  transport?: ITuffTransport
+  channel?: ITouchClientChannel
 }
 
 export interface FolderOpenOptions {
@@ -21,68 +46,130 @@ export interface ExternalUrlOptions {
   url: string
 }
 
+export interface TempFileCreateOptions {
+  namespace: string
+  ext?: string
+  text?: string
+  base64?: string
+  prefix?: string
+  retentionMs?: number
+}
+
+export interface TempFileCreateResult {
+  url: string
+  sizeBytes: number
+  createdAt: number
+}
+
+export interface TempFileDeleteOptions {
+  url?: string
+  path?: string
+}
+
+export interface TempFileDeleteResult {
+  success: boolean
+}
+
 export class TouchSDK {
-  private channel: ITouchClientChannel
+  private transport: ITuffTransport | null
+  private channel: ITouchClientChannel | null
 
   constructor(options: TouchSDKOptions) {
-    this.channel = options.channel
+    this.transport = options.transport ?? null
+    this.channel = options.channel ?? null
+  }
+
+  private async sendEvent<TReq, TRes>(event: TuffEvent<TReq, TRes>, payload?: TReq): Promise<TRes> {
+    if (this.transport) {
+      const shouldPassPayload = payload !== undefined
+      if (shouldPassPayload) {
+        return this.transport.send(event, payload)
+      }
+      return this.transport.send(event as TuffEvent<void, TRes>)
+    }
+
+    if (this.channel) {
+      return this.channel.send(event.toEventName(), payload as any) as Promise<TRes>
+    }
+
+    throw new Error('[TouchSDK] Transport or channel not initialized.')
   }
 
   /**
    * System Operations
    */
   async closeApp(): Promise<void> {
-    return this.channel.send('close')
+    return this.sendEvent(legacyCloseEvent)
   }
 
   async hideApp(): Promise<void> {
-    return this.channel.send('hide')
+    return this.sendEvent(legacyHideEvent)
   }
 
   async minimizeApp(): Promise<void> {
-    return this.channel.send('minimize')
+    return this.sendEvent(legacyMinimizeEvent)
   }
 
   async openDevTools(): Promise<void> {
-    return this.channel.send('dev-tools')
+    return this.sendEvent(legacyDevToolsEvent)
   }
 
   async getCurrentWorkingDirectory(): Promise<string> {
-    return this.channel.send('common:cwd')
+    return this.sendEvent(legacyCwdEvent)
   }
 
   async getPackageInfo(): Promise<any> {
-    return this.channel.send('get-package')
+    return this.sendEvent(legacyPackageEvent)
   }
 
   async getOSInfo(): Promise<any> {
-    return this.channel.send('get-os')
+    return this.sendEvent(legacyOsEvent)
   }
 
   /**
    * File & Folder Operations
    */
   async openFolder(options: FolderOpenOptions): Promise<void> {
-    return this.channel.send('folder:open', options)
+    return this.sendEvent(legacyFolderOpenEvent, options)
   }
 
   async executeCommand(options: ExecuteCommandOptions): Promise<void> {
-    return this.channel.send('execute:cmd', options)
+    return this.sendEvent(legacyExecuteCmdEvent, options)
   }
 
   async openApp(options: AppOpenOptions): Promise<void> {
-    return this.channel.send('app:open', options)
+    return this.sendEvent(legacyAppOpenEvent, options)
   }
 
   async openExternalUrl(options: ExternalUrlOptions): Promise<void> {
-    return this.channel.send('open-external', options)
+    return this.sendEvent(legacyOpenExternalEvent, options)
+  }
+
+  /**
+   * Temp file operations
+   */
+  async createTempFile(options: TempFileCreateOptions): Promise<TempFileCreateResult> {
+    return this.sendEvent(legacyTempFileCreateEvent, options)
+  }
+
+  async deleteTempFile(options: TempFileDeleteOptions): Promise<TempFileDeleteResult> {
+    return this.sendEvent(legacyTempFileDeleteEvent, options)
   }
 
   /**
    * Plugin Operations
    */
   async openPluginFolder(pluginName: string): Promise<void> {
-    return this.channel.send('plugin:explorer', pluginName)
+    return this.sendEvent(legacyPluginFolderEvent, pluginName)
+  }
+
+  /**
+   * Opens the DevTools for a plugin's Surface WebContents
+   * @param pluginName - The name of the plugin to open DevTools for
+   * @returns Promise that resolves when DevTools is opened
+   */
+  async openPluginDevTools(pluginName: string): Promise<void> {
+    return this.sendEvent(legacyPluginDevToolsEvent, pluginName)
   }
 
   /**
@@ -91,27 +178,36 @@ export class TouchSDK {
    * @returns Promise that resolves when the reload operation completes
    */
   async reloadPlugin(pluginName: string): Promise<void> {
-    return this.channel.send('reload-plugin', { name: pluginName })
+    return this.sendEvent(legacyPluginReloadEvent, { name: pluginName })
   }
 
   /**
    * Module Operations
    */
   async openModuleFolder(moduleName?: string): Promise<void> {
-    return this.channel.send('module:folder', { name: moduleName })
+    return this.sendEvent(legacyModuleFolderEvent, { name: moduleName })
   }
 
   /**
    * Event Registration
    */
   onChannelEvent(eventName: string, callback: (data: any) => void): () => void {
-    return this.channel.regChannel(eventName, callback)
+    if (this.transport) {
+      return this.transport.on(defineRawEvent<any, any>(eventName), callback)
+    }
+    if (this.channel) {
+      return this.channel.regChannel(eventName, callback)
+    }
+    throw new Error('[TouchSDK] Transport or channel not initialized.')
   }
 
   /**
    * Raw channel access for advanced usage
    */
   get rawChannel(): ITouchClientChannel {
+    if (!this.channel) {
+      throw new Error('[TouchSDK] Channel not initialized.')
+    }
     return this.channel
   }
 }

package/renderer/touch-sdk/terminal.ts

@@ -1,4 +1,15 @@
-import type { ITouchClientChannel } from '@talex-touch/utils/channel'
+import type { ITuffTransport } from '@talex-touch/utils/transport'
+import { defineRawEvent } from '@talex-touch/utils/transport/event/builder'
+
+const terminalCreateEvent = defineRawEvent<{ command: string, args?: string[] }, { id: string }>(
+  'terminal:create',
+)
+const terminalWriteEvent = defineRawEvent<{ id: string, data: string }, void>('terminal:write')
+const terminalKillEvent = defineRawEvent<{ id: string }, void>('terminal:kill')
+const terminalDataEvent = defineRawEvent<{ id: string, data: string }, void>('terminal:data')
+const terminalExitEvent = defineRawEvent<{ id: string, exitCode: number | null }, void>(
+  'terminal:exit',
+)
 
 type DataCallback = (data: string) => void
 type ExitCallback = (exitCode: number | null) => void
@@ -7,10 +18,10 @@ export class Terminal {
   private id: string | null = null
   private onDataCallback: DataCallback | null = null
   private onExitCallback: ExitCallback | null = null
-  private channel: ITouchClientChannel
+  private transport: ITuffTransport
 
-  constructor(channel: ITouchClientChannel) {
-    this.channel = channel
+  constructor(transport: ITuffTransport) {
+    this.transport = transport
   }
 
   /**
@@ -26,19 +37,19 @@ export class Terminal {
     // However, for simplicity in this refactor, we'll assume exec is called for a new, independent command.
     // A more robust implementation might track multiple concurrent processes.
 
-    const { id } = await this.channel.send('terminal:create', { command, args })
+    const { id } = await this.transport.send(terminalCreateEvent, { command, args })
     this.id = id
 
     // Re-register listeners for the new process ID
-    this.channel.regChannel('terminal:data', (channelData) => {
-      if (this.id === channelData.data.id && this.onDataCallback) {
-        this.onDataCallback(channelData.data.data)
+    this.transport.on(terminalDataEvent, (payload) => {
+      if (this.id === payload.id && this.onDataCallback) {
+        this.onDataCallback(payload.data)
       }
     })
 
-    this.channel.regChannel('terminal:exit', (channelData) => {
-      if (this.id === channelData.data.id && this.onExitCallback) {
-        this.onExitCallback(channelData.data.exitCode)
+    this.transport.on(terminalExitEvent, (payload) => {
+      if (this.id === payload.id && this.onExitCallback) {
+        this.onExitCallback(payload.exitCode)
         this.id = null
       }
     })
@@ -53,7 +64,7 @@ export class Terminal {
    */
   public write(data: string): void {
     if (this.id) {
-      this.channel.send('terminal:write', { id: this.id, data })
+      void this.transport.send(terminalWriteEvent, { id: this.id, data })
     }
   }
 
@@ -62,7 +73,7 @@ export class Terminal {
    */
   public kill(): void {
     if (this.id) {
-      this.channel.send('terminal:kill', { id: this.id })
+      void this.transport.send(terminalKillEvent, { id: this.id })
       this.id = null
     }
   }

package/search/feature-matcher.ts

@@ -0,0 +1,279 @@
+/**
+ * Feature Matching Utilities
+ *
+ * Provides enhanced search matching for plugin features with:
+ * - Pinyin/English token matching
+ * - Fuzzy match support
+ * - Match range generation for UI highlighting
+ */
+
+import { fuzzyMatch, indicesToRanges } from './fuzzy-match'
+
+/**
+ * Match range for highlighting
+ */
+export interface MatchRange {
+  start: number
+  end: number
+}
+
+/**
+ * Feature match result with score and highlight ranges
+ */
+export interface FeatureMatchResult {
+  /** Whether the feature matches the query */
+  matched: boolean
+  /** Match score (0-1000, higher is better) */
+  score: number
+  /** Match type for debugging */
+  matchType: 'exact' | 'token' | 'prefix' | 'contains' | 'fuzzy' | 'none'
+  /** Match ranges for highlighting in title */
+  matchRanges: MatchRange[]
+  /** Which token matched (for debugging) */
+  matchedToken?: string
+}
+
+/**
+ * Options for feature matching
+ */
+export interface FeatureMatchOptions {
+  /** Feature title/name */
+  title: string
+  /** Feature description */
+  desc?: string
+  /** Pre-computed search tokens (pinyin, initials, etc.) */
+  searchTokens?: string[]
+  /** Search query */
+  query: string
+  /** Enable fuzzy matching (default: true) */
+  enableFuzzy?: boolean
+  /** Maximum fuzzy errors (default: 2) */
+  maxFuzzyErrors?: number
+}
+
+/**
+ * Find substring match and return range
+ */
+function findSubstringMatch(text: string, query: string): MatchRange | null {
+  const lowerText = text.toLowerCase()
+  const lowerQuery = query.toLowerCase()
+  const index = lowerText.indexOf(lowerQuery)
+
+  if (index === -1)
+    return null
+
+  return { start: index, end: index + query.length }
+}
+
+/**
+ * Match query against a single token and return match info
+ */
+function matchToken(
+  token: string,
+  query: string,
+): { matched: boolean, score: number, type: 'exact' | 'prefix' | 'contains' | 'none' } {
+  const lowerToken = token.toLowerCase()
+  const lowerQuery = query.toLowerCase()
+
+  // Exact match
+  if (lowerToken === lowerQuery) {
+    return { matched: true, score: 1000, type: 'exact' }
+  }
+
+  // Prefix match (token starts with query)
+  if (lowerToken.startsWith(lowerQuery)) {
+    // Score based on how much of the token is matched
+    const coverage = lowerQuery.length / lowerToken.length
+    return { matched: true, score: 800 + Math.round(coverage * 100), type: 'prefix' }
+  }
+
+  // Contains match
+  if (lowerToken.includes(lowerQuery)) {
+    const coverage = lowerQuery.length / lowerToken.length
+    return { matched: true, score: 600 + Math.round(coverage * 50), type: 'contains' }
+  }
+
+  return { matched: false, score: 0, type: 'none' }
+}
+
+/**
+ * Match feature against search query
+ *
+ * This is the main matching function that:
+ * 1. Tries exact/prefix/contains match against title
+ * 2. Tries token matching (pinyin, initials, keywords)
+ * 3. Falls back to fuzzy matching
+ *
+ * @returns FeatureMatchResult with score and highlight ranges
+ */
+export function matchFeature(options: FeatureMatchOptions): FeatureMatchResult {
+  const {
+    title,
+    desc,
+    searchTokens = [],
+    query,
+    enableFuzzy = true,
+    maxFuzzyErrors = 2,
+  } = options
+
+  const trimmedQuery = query.trim()
+
+  // Empty query - no match
+  if (!trimmedQuery) {
+    return { matched: false, score: 0, matchType: 'none', matchRanges: [] }
+  }
+
+  const lowerQuery = trimmedQuery.toLowerCase()
+  const lowerTitle = title.toLowerCase()
+
+  // 1. Exact title match
+  if (lowerTitle === lowerQuery) {
+    return {
+      matched: true,
+      score: 1000,
+      matchType: 'exact',
+      matchRanges: [{ start: 0, end: title.length }],
+    }
+  }
+
+  // 2. Title prefix match
+  if (lowerTitle.startsWith(lowerQuery)) {
+    return {
+      matched: true,
+      score: 900,
+      matchType: 'prefix',
+      matchRanges: [{ start: 0, end: trimmedQuery.length }],
+    }
+  }
+
+  // 3. Title contains match
+  const titleMatch = findSubstringMatch(title, trimmedQuery)
+  if (titleMatch) {
+    return {
+      matched: true,
+      score: 700,
+      matchType: 'contains',
+      matchRanges: [titleMatch],
+    }
+  }
+
+  // 4. Search tokens matching (pinyin, initials, keywords)
+  // This enables searching "fanyi" to match "翻译"
+  if (searchTokens.length > 0) {
+    let bestTokenMatch: {
+      score: number
+      type: 'exact' | 'prefix' | 'contains'
+      token: string
+    } | null = null
+
+    for (const token of searchTokens) {
+      if (!token)
+        continue
+
+      const result = matchToken(token, trimmedQuery)
+      if (result.matched && (!bestTokenMatch || result.score > bestTokenMatch.score)) {
+        bestTokenMatch = {
+          score: result.score,
+          type: result.type as 'exact' | 'prefix' | 'contains',
+          token,
+        }
+      }
+    }
+
+    if (bestTokenMatch) {
+      // Token matched - highlight entire title since we can't map token back to characters
+      // For pinyin matches, the full Chinese title is relevant
+      return {
+        matched: true,
+        score: bestTokenMatch.score - 50, // Slightly lower than direct title match
+        matchType: 'token',
+        matchRanges: [{ start: 0, end: title.length }],
+        matchedToken: bestTokenMatch.token,
+      }
+    }
+  }
+
+  // 5. Description matching (lower priority)
+  if (desc) {
+    const descMatch = findSubstringMatch(desc, trimmedQuery)
+    if (descMatch) {
+      return {
+        matched: true,
+        score: 400,
+        matchType: 'contains',
+        matchRanges: [], // No title highlight for desc matches
+      }
+    }
+  }
+
+  // 6. Fuzzy matching on title
+  if (enableFuzzy) {
+    const fuzzyResult = fuzzyMatch(title, trimmedQuery, maxFuzzyErrors)
+    if (fuzzyResult.matched && fuzzyResult.score > 0.5) {
+      return {
+        matched: true,
+        score: Math.round(fuzzyResult.score * 500), // Scale to 0-500 range
+        matchType: 'fuzzy',
+        matchRanges: indicesToRanges(fuzzyResult.matchedIndices),
+      }
+    }
+
+    // Try fuzzy on tokens
+    for (const token of searchTokens) {
+      if (!token || token.length < 2)
+        continue
+
+      const tokenFuzzy = fuzzyMatch(token, trimmedQuery, maxFuzzyErrors)
+      if (tokenFuzzy.matched && tokenFuzzy.score > 0.6) {
+        return {
+          matched: true,
+          score: Math.round(tokenFuzzy.score * 400),
+          matchType: 'fuzzy',
+          matchRanges: [{ start: 0, end: title.length }],
+          matchedToken: token,
+        }
+      }
+    }
+  }
+
+  return { matched: false, score: 0, matchType: 'none', matchRanges: [] }
+}
+
+/**
+ * Batch match multiple features and return sorted results
+ *
+ * @param features Array of features with their search metadata
+ * @param query Search query
+ * @returns Features sorted by match score (highest first), with match metadata
+ */
+export function matchFeatures<T extends { searchTokens?: string[] }>(
+  features: Array<{
+    feature: T
+    title: string
+    desc?: string
+  }>,
+  query: string,
+): Array<{
+  feature: T
+  result: FeatureMatchResult
+}> {
+  const results: Array<{ feature: T, result: FeatureMatchResult }> = []
+
+  for (const { feature, title, desc } of features) {
+    const result = matchFeature({
+      title,
+      desc,
+      searchTokens: feature.searchTokens,
+      query,
+    })
+
+    if (result.matched) {
+      results.push({ feature, result })
+    }
+  }
+
+  // Sort by score descending
+  results.sort((a, b) => b.result.score - a.result.score)
+
+  return results
+}