@talex-touch/utils 1.0.40 → 1.0.44

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
 }

package/transport/errors.ts

@@ -0,0 +1,310 @@
+/**
+ * @fileoverview Error types for TuffTransport
+ * @module @talex-touch/utils/transport/errors
+ */
+
+// ============================================================================
+// Error Codes
+// ============================================================================
+
+/**
+ * Error codes for TuffTransport operations.
+ */
+export enum TuffTransportErrorCode {
+  /**
+   * Event is not a valid TuffEvent instance.
+   */
+  INVALID_EVENT = 'INVALID_EVENT',
+
+  /**
+   * No handler registered for the event.
+   */
+  UNKNOWN_EVENT = 'UNKNOWN_EVENT',
+
+  /**
+   * Request timed out waiting for response.
+   */
+  TIMEOUT = 'TIMEOUT',
+
+  /**
+   * Stream was cancelled by the client.
+   */
+  STREAM_CANCELLED = 'STREAM_CANCELLED',
+
+  /**
+   * Batch request failed.
+   */
+  BATCH_FAILED = 'BATCH_FAILED',
+
+  /**
+   * Failed to serialize request payload.
+   */
+  SERIALIZE_FAILED = 'SERIALIZE_FAILED',
+
+  /**
+   * Failed to deserialize response payload.
+   */
+  DESERIALIZE_FAILED = 'DESERIALIZE_FAILED',
+
+  /**
+   * Target window/WebContents not found or destroyed.
+   */
+  TARGET_NOT_FOUND = 'TARGET_NOT_FOUND',
+
+  /**
+   * Plugin security key is invalid or expired.
+   */
+  INVALID_PLUGIN_KEY = 'INVALID_PLUGIN_KEY',
+
+  /**
+   * Plugin attempted unauthorized operation.
+   */
+  PLUGIN_UNAUTHORIZED = 'PLUGIN_UNAUTHORIZED',
+
+  /**
+   * IPC channel error (e.g., EPIPE).
+   */
+  IPC_ERROR = 'IPC_ERROR',
+
+  /**
+   * Transport instance has been destroyed.
+   */
+  TRANSPORT_DESTROYED = 'TRANSPORT_DESTROYED',
+
+  /**
+   * Generic internal error.
+   */
+  INTERNAL_ERROR = 'INTERNAL_ERROR',
+}
+
+// ============================================================================
+// Error Class
+// ============================================================================
+
+/**
+ * Custom error class for TuffTransport operations.
+ *
+ * @remarks
+ * Provides structured error information including error codes,
+ * event context, and optional cause for error chaining.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await transport.send(event, payload)
+ * } catch (err) {
+ *   if (err instanceof TuffTransportError) {
+ *     switch (err.code) {
+ *       case TuffTransportErrorCode.TIMEOUT:
+ *         // Handle timeout
+ *         break
+ *       case TuffTransportErrorCode.INVALID_PLUGIN_KEY:
+ *         // Handle auth error
+ *         break
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class TuffTransportError extends Error {
+  /**
+   * Error code for programmatic handling.
+   */
+  readonly code: TuffTransportErrorCode
+
+  /**
+   * Event name associated with this error (if applicable).
+   */
+  readonly eventName?: string
+
+  /**
+   * Plugin name associated with this error (if applicable).
+   */
+  readonly pluginName?: string
+
+  /**
+   * Original error that caused this error (if applicable).
+   */
+  override readonly cause?: Error
+
+  /**
+   * Timestamp when this error occurred.
+   */
+  readonly timestamp: number
+
+  /**
+   * Creates a new TuffTransportError.
+   *
+   * @param code - Error code
+   * @param message - Human-readable error message
+   * @param options - Additional error context
+   */
+  constructor(
+    code: TuffTransportErrorCode,
+    message: string,
+    options?: {
+      eventName?: string
+      pluginName?: string
+      cause?: Error
+    },
+  ) {
+    super(message)
+    this.name = 'TuffTransportError'
+    this.code = code
+    this.eventName = options?.eventName
+    this.pluginName = options?.pluginName
+    this.cause = options?.cause
+    this.timestamp = Date.now()
+
+    // Maintain proper stack trace in V8 environments
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, TuffTransportError)
+    }
+  }
+
+  /**
+   * Creates a serializable representation of this error.
+   *
+   * @returns Plain object representation
+   */
+  toJSON(): Record<string, unknown> {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      eventName: this.eventName,
+      pluginName: this.pluginName,
+      timestamp: this.timestamp,
+      stack: this.stack,
+    }
+  }
+
+  /**
+   * Creates a TuffTransportError from a plain object.
+   *
+   * @param obj - Plain object (e.g., from IPC)
+   * @returns TuffTransportError instance
+   */
+  static fromJSON(obj: Record<string, unknown>): TuffTransportError {
+    const error = new TuffTransportError(
+      (obj.code as TuffTransportErrorCode) || TuffTransportErrorCode.INTERNAL_ERROR,
+      (obj.message as string) || 'Unknown error',
+      {
+        eventName: obj.eventName as string | undefined,
+        pluginName: obj.pluginName as string | undefined,
+      },
+    )
+    if (obj.stack && typeof obj.stack === 'string') {
+      error.stack = obj.stack
+    }
+    return error
+  }
+}
+
+// ============================================================================
+// Error Factory Functions
+// ============================================================================
+
+/**
+ * Creates an INVALID_EVENT error.
+ *
+ * @param context - Context where the error occurred
+ * @returns TuffTransportError
+ */
+export function createInvalidEventError(context: string): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.INVALID_EVENT,
+    `[${context}] Invalid event. Expected TuffEvent created via defineEvent(), `
+    + `received a string or invalid object. String event names are not allowed.`,
+  )
+}
+
+/**
+ * Creates a TIMEOUT error.
+ *
+ * @param eventName - Event that timed out
+ * @param timeoutMs - Timeout duration in milliseconds
+ * @returns TuffTransportError
+ */
+export function createTimeoutError(eventName: string, timeoutMs: number): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.TIMEOUT,
+    `Request "${eventName}" timed out after ${timeoutMs}ms`,
+    { eventName },
+  )
+}
+
+/**
+ * Creates an UNKNOWN_EVENT error.
+ *
+ * @param eventName - Event name that was not found
+ * @returns TuffTransportError
+ */
+export function createUnknownEventError(eventName: string): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.UNKNOWN_EVENT,
+    `No handler registered for event "${eventName}"`,
+    { eventName },
+  )
+}
+
+/**
+ * Creates an INVALID_PLUGIN_KEY error.
+ *
+ * @param pluginName - Plugin name (if known)
+ * @returns TuffTransportError
+ */
+export function createInvalidPluginKeyError(pluginName?: string): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.INVALID_PLUGIN_KEY,
+    pluginName
+      ? `Invalid or expired security key for plugin "${pluginName}"`
+      : 'Invalid or expired plugin security key',
+    { pluginName },
+  )
+}
+
+/**
+ * Creates a TARGET_NOT_FOUND error.
+ *
+ * @param target - Description of the target
+ * @param eventName - Event name (if applicable)
+ * @returns TuffTransportError
+ */
+export function createTargetNotFoundError(target: string, eventName?: string): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.TARGET_NOT_FOUND,
+    `Target "${target}" not found or has been destroyed`,
+    { eventName },
+  )
+}
+
+/**
+ * Creates a SERIALIZE_FAILED error.
+ *
+ * @param eventName - Event name
+ * @param cause - Original error
+ * @returns TuffTransportError
+ */
+export function createSerializeError(eventName: string, cause: Error): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.SERIALIZE_FAILED,
+    `Failed to serialize payload for "${eventName}": ${cause.message}`,
+    { eventName, cause },
+  )
+}
+
+/**
+ * Creates a STREAM_CANCELLED error.
+ *
+ * @param eventName - Event name
+ * @param streamId - Stream identifier
+ * @returns TuffTransportError
+ */
+export function createStreamCancelledError(eventName: string, streamId: string): TuffTransportError {
+  return new TuffTransportError(
+    TuffTransportErrorCode.STREAM_CANCELLED,
+    `Stream "${streamId}" for event "${eventName}" was cancelled`,
+    { eventName },
+  )
+}