@talex-touch/utils 1.0.39 → 1.0.42

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

package/types/division-box.ts

@@ -93,6 +93,23 @@ export interface HeaderConfig {
  */
 export type DivisionBoxSize = 'compact' | 'medium' | 'expanded'
 
+/**
+ * UI configuration for DivisionBox CoreBox header
+ */
+export interface DivisionBoxUIConfig {
+  /** Show the search input in header */
+  showInput?: boolean
+  
+  /** Placeholder text for search input */
+  inputPlaceholder?: string
+  
+  /** Show result list area */
+  showResults?: boolean
+  
+  /** Initial input value */
+  initialInput?: string
+}
+
 /**
  * Configuration for creating a DivisionBox instance
  */
@@ -118,6 +135,9 @@ export interface DivisionBoxConfig {
   /** Header configuration */
   header?: HeaderConfig
   
+  /** UI configuration for CoreBox header display */
+  ui?: DivisionBoxUIConfig
+  
   /** WebContentsView preferences (main process only) */
   webPreferences?: any
 }

package/types/flow.ts

@@ -0,0 +1,283 @@
+/**
+ * Flow Transfer Type Definitions
+ *
+ * Core types for the plugin-to-plugin data flow transfer system.
+ * Enables plugins to share structured data with other plugins' features.
+ */
+
+import type { TuffQuery } from '../core-box/tuff/tuff-dsl'
+
+/**
+ * Flow payload types
+ */
+export type FlowPayloadType = 'text' | 'image' | 'files' | 'json' | 'html' | 'custom'
+
+/**
+ * Flow session states
+ */
+export type FlowSessionState =
+  | 'INIT'
+  | 'TARGET_SELECTING'
+  | 'TARGET_SELECTED'
+  | 'DELIVERING'
+  | 'DELIVERED'
+  | 'PROCESSING'
+  | 'ACKED'
+  | 'FAILED'
+  | 'CANCELLED'
+
+/**
+ * Flow error codes
+ */
+export enum FlowErrorCode {
+  SENDER_NOT_ALLOWED = 'SENDER_NOT_ALLOWED',
+  TARGET_NOT_FOUND = 'TARGET_NOT_FOUND',
+  TARGET_OFFLINE = 'TARGET_OFFLINE',
+  PAYLOAD_INVALID = 'PAYLOAD_INVALID',
+  PAYLOAD_TOO_LARGE = 'PAYLOAD_TOO_LARGE',
+  TYPE_NOT_SUPPORTED = 'TYPE_NOT_SUPPORTED',
+  PERMISSION_DENIED = 'PERMISSION_DENIED',
+  TIMEOUT = 'TIMEOUT',
+  CANCELLED = 'CANCELLED',
+  INTERNAL_ERROR = 'INTERNAL_ERROR'
+}
+
+/**
+ * Flow error
+ */
+export interface FlowError {
+  code: FlowErrorCode
+  message: string
+  details?: Record<string, any>
+}
+
+/**
+ * Flow payload context
+ */
+export interface FlowPayloadContext {
+  /** Source plugin ID */
+  sourcePluginId: string
+
+  /** Source feature ID (optional) */
+  sourceFeatureId?: string
+
+  /** Original query (if triggered from CoreBox) */
+  originalQuery?: TuffQuery
+
+  /** Custom metadata */
+  metadata?: Record<string, any>
+}
+
+/**
+ * Flow payload - data being transferred
+ */
+export interface FlowPayload {
+  /** Payload type */
+  type: FlowPayloadType
+
+  /** Main data content */
+  data: string | object
+
+  /** MIME type (optional) */
+  mimeType?: string
+
+  /** Context information */
+  context?: FlowPayloadContext
+}
+
+/**
+ * Flow target capabilities
+ */
+export interface FlowTargetCapabilities {
+  /** Whether authentication is required */
+  requiresAuth?: boolean
+
+  /** Allowed sender plugin IDs (whitelist) */
+  allowedSenders?: string[]
+
+  /** Maximum payload size in bytes */
+  maxPayloadSize?: number
+}
+
+/**
+ * Flow target - declared in plugin manifest
+ */
+export interface FlowTarget {
+  /** Target unique ID (unique within plugin) */
+  id: string
+
+  /** Display name */
+  name: string
+
+  /** Description */
+  description?: string
+
+  /** Supported payload types */
+  supportedTypes: FlowPayloadType[]
+
+  /** Icon (iconify format) */
+  icon?: string
+
+  /** Associated feature ID (optional) */
+  featureId?: string
+
+  /** Associated action ID (optional) */
+  actionId?: string
+
+  /** Whether user confirmation is required */
+  requireConfirm?: boolean
+
+  /** Capability requirements */
+  capabilities?: FlowTargetCapabilities
+}
+
+/**
+ * Flow target info - runtime information
+ */
+export interface FlowTargetInfo extends FlowTarget {
+  /** Full target ID (pluginId.targetId) */
+  fullId: string
+
+  /** Plugin ID */
+  pluginId: string
+
+  /** Plugin name */
+  pluginName?: string
+
+  /** Plugin icon */
+  pluginIcon?: string
+
+  /** Whether the plugin is currently enabled */
+  isEnabled: boolean
+
+  /** Recent usage count */
+  usageCount?: number
+
+  /** Last used timestamp */
+  lastUsed?: number
+}
+
+/**
+ * Flow session - a complete flow operation
+ */
+export interface FlowSession {
+  /** Session unique ID */
+  sessionId: string
+
+  /** Session state */
+  state: FlowSessionState
+
+  /** Sender plugin ID */
+  senderId: string
+
+  /** Target plugin ID */
+  targetPluginId: string
+
+  /** Target endpoint ID */
+  targetId: string
+
+  /** Full target ID (pluginId.targetId) */
+  fullTargetId: string
+
+  /** Payload data */
+  payload: FlowPayload
+
+  /** Creation timestamp */
+  createdAt: number
+
+  /** Update timestamp */
+  updatedAt: number
+
+  /** Acknowledgment payload (if any) */
+  ackPayload?: any
+
+  /** Error information (if failed) */
+  error?: FlowError
+}
+
+/**
+ * Flow dispatch options
+ */
+export interface FlowDispatchOptions {
+  /** Display title (for selector panel) */
+  title?: string
+
+  /** Display description */
+  description?: string
+
+  /** Preferred target (bundleId.targetId or tuffItemId) */
+  preferredTarget?: string
+
+  /** Skip selector panel (requires preferredTarget) */
+  skipSelector?: boolean
+
+  /** Timeout in milliseconds (default: 30000) */
+  timeout?: number
+
+  /** Fallback action on failure */
+  fallbackAction?: 'copy' | 'none'
+
+  /** Whether acknowledgment is required */
+  requireAck?: boolean
+}
+
+/**
+ * Flow dispatch result
+ */
+export interface FlowDispatchResult {
+  /** Session ID */
+  sessionId: string
+
+  /** Final state */
+  state: FlowSessionState
+
+  /** Acknowledgment payload */
+  ackPayload?: any
+
+  /** Error (if failed) */
+  error?: FlowError
+}
+
+/**
+ * Flow session update event
+ */
+export interface FlowSessionUpdate {
+  /** Session ID */
+  sessionId: string
+
+  /** Previous state */
+  previousState: FlowSessionState
+
+  /** Current state */
+  currentState: FlowSessionState
+
+  /** Timestamp */
+  timestamp: number
+
+  /** Additional data */
+  data?: any
+}
+
+/**
+ * IPC channels for Flow operations
+ */
+export enum FlowIPCChannel {
+  DISPATCH = 'flow:dispatch',
+  GET_TARGETS = 'flow:get-targets',
+  CANCEL = 'flow:cancel',
+  ACKNOWLEDGE = 'flow:acknowledge',
+  REPORT_ERROR = 'flow:report-error',
+  SESSION_UPDATE = 'flow:session-update',
+  DELIVER = 'flow:deliver'
+}
+
+/**
+ * Flow manifest configuration (in plugin manifest.json)
+ */
+export interface FlowManifestConfig {
+  /** Whether this plugin can send flows */
+  flowSender?: boolean
+
+  /** Flow targets this plugin can receive */
+  flowTargets?: FlowTarget[]
+}

package/types/index.ts

@@ -1,4 +1,5 @@
 export * from './division-box'
+export * from './flow'
 export * from './intelligence'
 export * from './modules'
 export * from './storage'