@talex-touch/utils 1.0.42 → 1.0.45

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
+}

package/search/fuzzy-match.ts

@@ -24,7 +24,7 @@ export interface FuzzyMatchResult {
 export function fuzzyMatch(
   target: string,
   query: string,
-  maxErrors = 2
+  maxErrors = 2,
 ): FuzzyMatchResult {
   if (!query || !target) {
     return { matched: false, score: 0, matchedIndices: [] }
@@ -38,7 +38,7 @@ export function fuzzyMatch(
     return {
       matched: true,
       score: 1,
-      matchedIndices: Array.from({ length: target.length }, (_, i) => i)
+      matchedIndices: Array.from({ length: target.length }, (_, i) => i),
     }
   }
 
@@ -48,7 +48,7 @@ export function fuzzyMatch(
     return {
       matched: true,
       score: 0.95,
-      matchedIndices: Array.from({ length: query.length }, (_, i) => substringIndex + i)
+      matchedIndices: Array.from({ length: query.length }, (_, i) => substringIndex + i),
     }
   }
 
@@ -58,7 +58,7 @@ export function fuzzyMatch(
     return {
       matched: true,
       score: 0.8 + (subsequenceResult.matchedIndices.length / target.length) * 0.1,
-      matchedIndices: subsequenceResult.matchedIndices
+      matchedIndices: subsequenceResult.matchedIndices,
     }
   }
 
@@ -77,8 +77,8 @@ export function fuzzyMatch(
  */
 function subsequenceMatch(
   target: string,
-  query: string
-): { matched: boolean; matchedIndices: number[] } {
+  query: string,
+): { matched: boolean, matchedIndices: number[] } {
   const matchedIndices: number[] = []
   let queryIdx = 0
 
@@ -91,7 +91,7 @@ function subsequenceMatch(
 
   return {
     matched: queryIdx === query.length,
-    matchedIndices
+    matchedIndices,
   }
 }
 
@@ -102,13 +102,15 @@ function subsequenceMatch(
 function fuzzyMatchWithErrors(
   target: string,
   query: string,
-  maxErrors: number
+  maxErrors: number,
 ): FuzzyMatchResult {
   const m = query.length
   const n = target.length
 
-  if (m === 0) return { matched: true, score: 1, matchedIndices: [] }
-  if (n === 0) return { matched: false, score: 0, matchedIndices: [] }
+  if (m === 0)
+    return { matched: true, score: 1, matchedIndices: [] }
+  if (n === 0)
+    return { matched: false, score: 0, matchedIndices: [] }
 
   // Allow more errors for longer queries
   const allowedErrors = Math.min(maxErrors, Math.floor(m / 3) + 1)
@@ -135,7 +137,7 @@ function fuzzyMatchWithErrors(
           bestScore = score
           bestStart = start
           // Adjust indices to be relative to the full target string
-          bestMatchedIndices = matchedIndices.map((i) => start + i)
+          bestMatchedIndices = matchedIndices.map(i => start + i)
         }
       }
     }
@@ -145,7 +147,7 @@ function fuzzyMatchWithErrors(
     return {
       matched: true,
       score: bestScore,
-      matchedIndices: bestMatchedIndices
+      matchedIndices: bestMatchedIndices,
     }
   }
 
@@ -157,25 +159,41 @@ function fuzzyMatchWithErrors(
  */
 function editDistanceWithPath(
   s1: string,
-  s2: string
-): { distance: number; matchedIndices: number[] } {
+  s2: string,
+): { distance: number, matchedIndices: number[] } {
   const m = s1.length
   const n = s2.length
 
   // DP table
-  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0))
 
   // Initialize
-  for (let i = 0; i <= m; i++) dp[i][0] = i
-  for (let j = 0; j <= n; j++) dp[0][j] = j
+  for (let i = 0; i <= m; i++) {
+    const row = dp[i]
+    if (row)
+      row[0] = i
+  }
+  const firstRow = dp[0]
+  if (firstRow) {
+    for (let j = 0; j <= n; j++)
+      firstRow[j] = j
+  }
 
   // Fill DP table
   for (let i = 1; i <= m; i++) {
     for (let j = 1; j <= n; j++) {
+      const row = dp[i]
+      const prevRow = dp[i - 1]
+      if (!row || !prevRow)
+        continue
       if (s1[i - 1] === s2[j - 1]) {
-        dp[i][j] = dp[i - 1][j - 1]
-      } else {
-        dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
+        row[j] = prevRow[j - 1] ?? 0
+      }
+      else {
+        const up = prevRow[j] ?? 0
+        const left = row[j - 1] ?? 0
+        const diag = prevRow[j - 1] ?? 0
+        row[j] = 1 + Math.min(up, left, diag)
       }
     }
   }
@@ -190,20 +208,24 @@ function editDistanceWithPath(
       matchedIndices.unshift(i - 1)
       i--
       j--
-    } else if (dp[i - 1][j - 1] <= dp[i - 1][j] && dp[i - 1][j - 1] <= dp[i][j - 1]) {
+    }
+    else if ((dp[i - 1]?.[j - 1] ?? 0) <= (dp[i - 1]?.[j] ?? 0)
+      && (dp[i - 1]?.[j - 1] ?? 0) <= (dp[i]?.[j - 1] ?? 0)) {
       // Substitution
       i--
       j--
-    } else if (dp[i - 1][j] <= dp[i][j - 1]) {
+    }
+    else if ((dp[i - 1]?.[j] ?? 0) <= (dp[i]?.[j - 1] ?? 0)) {
       // Deletion from s1
       i--
-    } else {
+    }
+    else {
       // Insertion into s1
       j--
     }
   }
 
-  return { distance: dp[m][n], matchedIndices }
+  return { distance: dp[m]?.[n] ?? 0, matchedIndices }
 }
 
 /**
@@ -213,7 +235,7 @@ function calculateFuzzyScore(
   editDistance: number,
   queryLength: number,
   matchStart: number,
-  targetLength: number
+  targetLength: number,
 ): number {
   // Base score from edit distance (0.5 - 0.7 range for fuzzy matches)
   const distanceScore = Math.max(0, 1 - editDistance / queryLength) * 0.3 + 0.4
@@ -230,22 +252,30 @@ function calculateFuzzyScore(
 /**
  * Convert matched indices to Range array for highlighting
  */
-export function indicesToRanges(indices: number[]): Array<{ start: number; end: number }> {
-  if (!indices.length) return []
+export function indicesToRanges(indices: number[]): Array<{ start: number, end: number }> {
+  if (!indices.length)
+    return []
 
   const sorted = Array.from(new Set(indices)).sort((a, b) => a - b)
-  const ranges: Array<{ start: number; end: number }> = []
+  const ranges: Array<{ start: number, end: number }> = []
 
-  let start = sorted[0]
-  let end = sorted[0] + 1
+  const first = sorted[0]
+  if (first === undefined)
+    return []
+  let start = first
+  let end = first + 1
 
   for (let i = 1; i < sorted.length; i++) {
-    if (sorted[i] === end) {
+    const current = sorted[i]
+    if (current === undefined)
+      continue
+    if (current === end) {
       end++
-    } else {
+    }
+    else {
       ranges.push({ start, end })
-      start = sorted[i]
-      end = sorted[i] + 1
+      start = current
+      end = current + 1
     }
   }
   ranges.push({ start, end })

package/search/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Search utilities and types
+ *
+ * @module search
+ */
+
+export * from './feature-matcher'
+export * from './fuzzy-match'
+export * from './levenshtein-utils'
+export * from './types'

package/search/levenshtein-utils.ts

@@ -11,29 +11,35 @@ export function levenshteinDistance(s1: string, s2: string): number {
   const n = s2.length
 
   // Create a 2D array (m+1)x(n+1) to store distances
-  const dp: number[][] = new Array(m + 1)
-    .fill(0)
-    .map(() => new Array(n + 1).fill(0))
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array.from({ length: n + 1 }, () => 0))
 
   // Initialize the DP table
   for (let i = 0; i <= m; i++) {
-    dp[i][0] = i
+    const row = dp[i]
+    if (row)
+      row[0] = i
   }
-  for (let j = 0; j <= n; j++) {
-    dp[0][j] = j
+  const firstRow = dp[0]
+  if (firstRow) {
+    for (let j = 0; j <= n; j++)
+      firstRow[j] = j
   }
 
   // Fill the DP table
   for (let i = 1; i <= m; i++) {
     for (let j = 1; j <= n; j++) {
       const cost = s1[i - 1] === s2[j - 1] ? 0 : 1
-      dp[i][j] = Math.min(
-        dp[i - 1][j] + 1, // Deletion
-        dp[i][j - 1] + 1, // Insertion
-        dp[i - 1][j - 1] + cost, // Substitution
+      const row = dp[i]
+      const prevRow = dp[i - 1]
+      if (!row || !prevRow)
+        continue
+      row[j] = Math.min(
+        (prevRow[j] ?? 0) + 1, // Deletion
+        (row[j - 1] ?? 0) + 1, // Insertion
+        (prevRow[j - 1] ?? 0) + cost, // Substitution
       )
     }
   }
 
-  return dp[m][n]
+  return dp[m]?.[n] ?? 0
 }