@talex-touch/utils 1.0.38 → 1.0.40

package/renderer/storage/base-storage.ts

@@ -113,6 +113,15 @@ export function createStorageProxy<T extends object>(key: string, factory: () =>
   })
 }
 
+/**
+ * Save result from main process
+ */
+export interface SaveResult {
+  success: boolean
+  version: number
+  conflict?: boolean
+}
+
 /**
  * A reactive storage utility with optional auto-save and update subscriptions.
  *
@@ -127,6 +136,8 @@ export class TouchStorage<T extends object> {
   private readonly _onUpdate: Array<() => void> = []
   #channelInitialized = false
   #skipNextWatchTrigger = false
+  #currentVersion = 0
+  #isRemoteUpdate = false
 
   /**
    * The reactive data exposed to users.
@@ -189,17 +200,29 @@ export class TouchStorage<T extends object> {
 
     this.#channelInitialized = true
 
-    const result = channel!.sendSync('storage:get', this.#qualifiedName)
-    const parsed = result ? (result as Partial<T>) : {}
-
-    this.assignData(parsed)
+    // Try to get versioned data first, fallback to legacy
+    const versionedResult = channel!.sendSync('storage:get-versioned', this.#qualifiedName) as { data: Partial<T>, version: number } | null
+    if (versionedResult) {
+      this.#currentVersion = versionedResult.version
+      this.assignData(versionedResult.data, true, true)
+    }
+    else {
+      const result = channel!.sendSync('storage:get', this.#qualifiedName)
+      const parsed = result ? (result as Partial<T>) : {}
+      this.#currentVersion = 1
+      this.assignData(parsed, true, true)
+    }
 
-    // Register update listener
+    // Register update listener - only triggered for OTHER windows' changes
+    // (source window is excluded by main process)
     channel!.regChannel('storage:update', ({ data }) => {
-      const { name } = data!
+      const { name, version } = data as { name: string, version?: number }
 
       if (name === this.#qualifiedName) {
-        this.loadFromRemote()
+        // Only reload if remote version is newer
+        if (version === undefined || version > this.#currentVersion) {
+          this.#loadFromRemoteWithVersion()
+        }
       }
     })
 
@@ -209,6 +232,24 @@ export class TouchStorage<T extends object> {
     }
   }
 
+  /**
+   * Load from remote and update version
+   * @private
+   */
+  #loadFromRemoteWithVersion(): void {
+    if (!channel)
+      return
+
+    const versionedResult = channel.sendSync('storage:get-versioned', this.#qualifiedName) as { data: Partial<T>, version: number } | null
+    if (versionedResult && versionedResult.version > this.#currentVersion) {
+      this.#currentVersion = versionedResult.version
+      // Mark as remote update to skip auto-save
+      this.#isRemoteUpdate = true
+      this.assignData(versionedResult.data, true, true)
+      this.#isRemoteUpdate = false
+    }
+  }
+
   /**
    * Returns the unique identifier of this storage.
    *
@@ -253,11 +294,26 @@ export class TouchStorage<T extends object> {
       return
     }
 
-    await channel.send('storage:save', {
+    // Skip save if this is a remote update (to avoid echo)
+    if (this.#isRemoteUpdate) {
+      return
+    }
+
+    const result = await channel.send('storage:save', {
       key: this.#qualifiedName,
       content: JSON.stringify(this.data),
       clear: false,
-    })
+      version: this.#currentVersion,
+    }) as SaveResult
+
+    if (result.success) {
+      this.#currentVersion = result.version
+    }
+    else if (result.conflict) {
+      // Conflict detected - reload from remote
+      console.warn(`[TouchStorage] Conflict detected for "${this.#qualifiedName}", reloading...`)
+      this.#loadFromRemoteWithVersion()
+    }
   }, 300)
 
   /**
@@ -364,8 +420,9 @@ export class TouchStorage<T extends object> {
    *
    * @param newData Partial update data
    * @param stopWatch Whether to stop the watcher during assignment
+   * @param skipSave Whether to skip saving (for remote updates)
    */
-  private assignData(newData: Partial<T>, stopWatch: boolean = true): void {
+  private assignData(newData: Partial<T>, stopWatch: boolean = true, skipSave: boolean = false): void {
     if (stopWatch && this.#autoSave) {
       this.#assigning = true
     }
@@ -385,7 +442,10 @@ export class TouchStorage<T extends object> {
         Promise.resolve().then(resetAssigning)
       }
 
-      this.#runAutoSavePipeline({ force: true })
+      // Only run auto-save pipeline if not a remote update
+      if (!skipSave && !this.#isRemoteUpdate) {
+        this.#runAutoSavePipeline({ force: true })
+      }
     }
   }
 
@@ -444,13 +504,36 @@ export class TouchStorage<T extends object> {
       return this
     }
 
-    const result = channel.sendSync('storage:get', this.#qualifiedName)
-    const parsed = result ? (result as Partial<T>) : {}
-    this.assignData(parsed, true)
-
+    this.#loadFromRemoteWithVersion()
     return this
   }
 
+  /**
+   * Get current version number
+   * @returns Current version
+   */
+  getVersion(): number {
+    return this.#currentVersion
+  }
+
+  /**
+   * Save data synchronously (for window close)
+   * This bypasses debouncing and saves immediately
+   */
+  saveSync(): void {
+    if (!channel)
+      return
+    if (this.#isRemoteUpdate)
+      return
+
+    channel.sendSync('storage:save-sync', {
+      key: this.#qualifiedName,
+      content: JSON.stringify(this.data),
+      clear: false,
+      version: this.#currentVersion,
+    })
+  }
+
   /**
    * Gets the current data state.
    *

package/renderer/storage/storage-subscription.ts

@@ -14,6 +14,7 @@ class StorageSubscriptionManager {
   private subscribers = new Map<string, Set<StorageSubscriptionCallback>>()
   private channelListenerRegistered = false
   private pendingUpdates = new Map<string, NodeJS.Timeout>()
+  private configVersions = new Map<string, number>()
 
   /**
    * Initialize the subscription manager with a channel
@@ -24,8 +25,15 @@ class StorageSubscriptionManager {
     if (!this.channelListenerRegistered) {
       // Listen to storage:update events from main process
       this.channel.regChannel('storage:update', ({ data }) => {
-        const { name } = data as { name: string }
-        this.handleStorageUpdate(name)
+        const { name, version } = data as { name: string, version?: number }
+        // Only handle update if version is newer or unknown
+        const currentVersion = this.configVersions.get(name) ?? 0
+        if (version === undefined || version > currentVersion) {
+          if (version !== undefined) {
+            this.configVersions.set(name, version)
+          }
+          this.handleStorageUpdate(name)
+        }
       })
       this.channelListenerRegistered = true
     }
@@ -36,13 +44,13 @@ class StorageSubscriptionManager {
    * @param configName - The configuration file name (e.g., 'app-setting.ini')
    * @param callback - Callback function to receive updates
    * @returns Unsubscribe function
-   * 
+   *
    * @example
    * ```typescript
    * const unsubscribe = subscribeStorage('app-setting.ini', (data) => {
    *   console.log('Config updated:', data)
    * })
-   * 
+   *
    * // Later:
    * unsubscribe()
    * ```
@@ -155,7 +163,7 @@ const subscriptionManager = new StorageSubscriptionManager()
 /**
  * Initialize storage subscription system with channel
  * Must be called before using subscribeStorage
- * 
+ *
  * @param channel - The storage channel
  */
 export function initStorageSubscription(channel: IStorageChannel): void {
@@ -164,19 +172,19 @@ export function initStorageSubscription(channel: IStorageChannel): void {
 
 /**
  * Subscribe to storage configuration changes
- * 
+ *
  * @param configName - Configuration file name (e.g., 'app-setting.ini')
  * @param callback - Callback function that receives updated data
  * @returns Unsubscribe function
- * 
+ *
  * @example
  * ```typescript
  * import { subscribeStorage } from '@talex-touch/utils/renderer/storage/storage-subscription'
- * 
+ *
  * const unsubscribe = subscribeStorage('app-setting.ini', (data) => {
  *   console.log('Settings updated:', data)
  * })
- * 
+ *
  * // Clean up when no longer needed
  * unsubscribe()
  * ```

package/search/fuzzy-match.ts

@@ -0,0 +1,254 @@
+/**
+ * Fuzzy matching utilities for typo-tolerant search
+ * Supports matching queries like "helol" to "hello"
+ */
+
+export interface FuzzyMatchResult {
+  /** Whether the match was successful */
+  matched: boolean
+  /** Match score (0-1, higher is better) */
+  score: number
+  /** Indices of matched characters in the target string */
+  matchedIndices: number[]
+}
+
+/**
+ * Performs fuzzy matching with typo tolerance
+ * Uses a combination of subsequence matching and edit distance
+ *
+ * @param target - The string to match against (e.g., "hello")
+ * @param query - The search query (e.g., "helol")
+ * @param maxErrors - Maximum allowed errors (default: 2)
+ * @returns FuzzyMatchResult with match info and indices
+ */
+export function fuzzyMatch(
+  target: string,
+  query: string,
+  maxErrors = 2
+): FuzzyMatchResult {
+  if (!query || !target) {
+    return { matched: false, score: 0, matchedIndices: [] }
+  }
+
+  const targetLower = target.toLowerCase()
+  const queryLower = query.toLowerCase()
+
+  // Exact match - highest score
+  if (targetLower === queryLower) {
+    return {
+      matched: true,
+      score: 1,
+      matchedIndices: Array.from({ length: target.length }, (_, i) => i)
+    }
+  }
+
+  // Substring match
+  const substringIndex = targetLower.indexOf(queryLower)
+  if (substringIndex !== -1) {
+    return {
+      matched: true,
+      score: 0.95,
+      matchedIndices: Array.from({ length: query.length }, (_, i) => substringIndex + i)
+    }
+  }
+
+  // Try subsequence matching first (for cases like "vsc" -> "Visual Studio Code")
+  const subsequenceResult = subsequenceMatch(targetLower, queryLower)
+  if (subsequenceResult.matched && subsequenceResult.matchedIndices.length === queryLower.length) {
+    return {
+      matched: true,
+      score: 0.8 + (subsequenceResult.matchedIndices.length / target.length) * 0.1,
+      matchedIndices: subsequenceResult.matchedIndices
+    }
+  }
+
+  // Fuzzy match with edit distance for typo tolerance
+  const fuzzyResult = fuzzyMatchWithErrors(targetLower, queryLower, maxErrors)
+  if (fuzzyResult.matched) {
+    return fuzzyResult
+  }
+
+  return { matched: false, score: 0, matchedIndices: [] }
+}
+
+/**
+ * Subsequence matching - matches characters in order but not necessarily consecutive
+ * e.g., "vsc" matches "Visual Studio Code" at indices [0, 7, 14]
+ */
+function subsequenceMatch(
+  target: string,
+  query: string
+): { matched: boolean; matchedIndices: number[] } {
+  const matchedIndices: number[] = []
+  let queryIdx = 0
+
+  for (let i = 0; i < target.length && queryIdx < query.length; i++) {
+    if (target[i] === query[queryIdx]) {
+      matchedIndices.push(i)
+      queryIdx++
+    }
+  }
+
+  return {
+    matched: queryIdx === query.length,
+    matchedIndices
+  }
+}
+
+/**
+ * Fuzzy matching with error tolerance using dynamic programming
+ * Finds the best matching substring allowing for insertions, deletions, and substitutions
+ */
+function fuzzyMatchWithErrors(
+  target: string,
+  query: string,
+  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: [] }
+
+  // Allow more errors for longer queries
+  const allowedErrors = Math.min(maxErrors, Math.floor(m / 3) + 1)
+
+  // Find best matching window using sliding window with edit distance
+  let bestScore = 0
+  let bestStart = -1
+  let bestMatchedIndices: number[] = []
+
+  // Try different window sizes around query length
+  const minWindowSize = Math.max(1, m - allowedErrors)
+  const maxWindowSize = Math.min(n, m + allowedErrors)
+
+  for (let windowSize = minWindowSize; windowSize <= maxWindowSize; windowSize++) {
+    for (let start = 0; start <= n - windowSize; start++) {
+      const window = target.substring(start, start + windowSize)
+      const { distance, matchedIndices } = editDistanceWithPath(window, query)
+
+      if (distance <= allowedErrors) {
+        // Calculate score based on edit distance and position
+        const score = calculateFuzzyScore(distance, m, start, n)
+
+        if (score > bestScore) {
+          bestScore = score
+          bestStart = start
+          // Adjust indices to be relative to the full target string
+          bestMatchedIndices = matchedIndices.map((i) => start + i)
+        }
+      }
+    }
+  }
+
+  if (bestStart !== -1) {
+    return {
+      matched: true,
+      score: bestScore,
+      matchedIndices: bestMatchedIndices
+    }
+  }
+
+  return { matched: false, score: 0, matchedIndices: [] }
+}
+
+/**
+ * Computes edit distance and tracks which characters matched
+ */
+function editDistanceWithPath(
+  s1: string,
+  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))
+
+  // Initialize
+  for (let i = 0; i <= m; i++) dp[i][0] = i
+  for (let j = 0; j <= n; j++) dp[0][j] = j
+
+  // Fill DP table
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      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])
+      }
+    }
+  }
+
+  // Backtrack to find matched indices
+  const matchedIndices: number[] = []
+  let i = m
+  let j = n
+
+  while (i > 0 && j > 0) {
+    if (s1[i - 1] === s2[j - 1]) {
+      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]) {
+      // Substitution
+      i--
+      j--
+    } else if (dp[i - 1][j] <= dp[i][j - 1]) {
+      // Deletion from s1
+      i--
+    } else {
+      // Insertion into s1
+      j--
+    }
+  }
+
+  return { distance: dp[m][n], matchedIndices }
+}
+
+/**
+ * Calculate fuzzy match score based on various factors
+ */
+function calculateFuzzyScore(
+  editDistance: number,
+  queryLength: number,
+  matchStart: 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
+
+  // Bonus for matching at the start
+  const positionBonus = matchStart === 0 ? 0.15 : 0
+
+  // Bonus for shorter targets (more specific matches)
+  const lengthBonus = Math.min(0.1, queryLength / targetLength * 0.1)
+
+  return Math.min(0.75, distanceScore + positionBonus + lengthBonus)
+}
+
+/**
+ * Convert matched indices to Range array for highlighting
+ */
+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 }> = []
+
+  let start = sorted[0]
+  let end = sorted[0] + 1
+
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i] === end) {
+      end++
+    } else {
+      ranges.push({ start, end })
+      start = sorted[i]
+      end = sorted[i] + 1
+    }
+  }
+  ranges.push({ start, end })
+
+  return ranges
+}