@talex-touch/utils 1.0.18 → 1.0.20

package/electron/clipboard-helper.ts

@@ -0,0 +1,199 @@
+import { clipboard } from 'electron'
+
+/**
+ * Represents a file object from the clipboard
+ */
+interface ClipboardFileInfo {
+  /** File data as a buffer */
+  buffer: Buffer
+  /** MIME type of the file */
+  mimetype: string
+  /** Original filename */
+  originalname: string
+}
+
+/**
+ * Possible return types from clipboard file operations
+ */
+export type ClipboardFileResult = string | ClipboardFileInfo
+
+/**
+ * Utility class for handling clipboard file operations across different platforms
+ */
+export class ClipboardHelper {
+  /**
+   * Check if the current platform is macOS
+   * @private
+   */
+  private get isMac(): boolean {
+    return process.platform === 'darwin'
+  }
+
+  /**
+   * Generate a unique identifier with specified length and radix
+   * @param length - Length of the generated string
+   * @param radix - Radix for number conversion (default: 16)
+   * @returns Generated unique identifier
+   * @private
+   */
+  private generateUuid(length: number, radix: number = 16): string {
+    const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('')
+    const uuid: string[] = []
+    let i: number
+
+    radix = radix || chars.length
+
+    if (length) {
+      for (i = 0; i < length; i++) {
+        uuid[i] = chars[0 | (Math.random() * radix)]
+      }
+    } else {
+      let r: number
+      uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-'
+      uuid[14] = '4'
+
+      for (i = 0; i < 36; i++) {
+        if (!uuid[i]) {
+          r = 0 | (Math.random() * 16)
+          uuid[i] = chars[i === 19 ? (r & 0x3) | 0x8 : r]
+        }
+      }
+    }
+
+    return uuid.join('')
+  }
+
+  /**
+   * Process clipboard files on macOS platform
+   * @returns Array of file paths or file info objects
+   * @private
+   */
+  private getClipboardFilesMac(): ClipboardFileResult[] {
+    let filePath: ClipboardFileResult[] = []
+
+    if (clipboard.has('NSFilenamesPboardType')) {
+      // Handle multiple files
+      const tagContent = clipboard.read('NSFilenamesPboardType').match(/<string>.*<\/string>/g)
+      filePath = tagContent ? tagContent.map(item => item.replace(/<string>|<\/string>/g, '')) : []
+    } else {
+      // Handle single file
+      const clipboardImage = clipboard.readImage('clipboard')
+      if (!clipboardImage.isEmpty()) {
+        // Handle image from clipboard
+        const png = clipboardImage.toPNG()
+        const fileInfo: ClipboardFileInfo = {
+          buffer: png,
+          mimetype: 'image/png',
+          originalname: this.generateUuid(8, 16) + '.png'
+        }
+        filePath = [fileInfo]
+      } else {
+        // Handle single file path
+        const fileUrl = clipboard.read('public.file-url')
+        if (fileUrl) {
+          filePath = [fileUrl.replace('file://', '')].filter(item => item)
+        }
+      }
+    }
+
+    return filePath
+  }
+
+  /**
+   * Process clipboard files on Windows platform
+   * @returns Array of file paths or file info objects
+   * @private
+   */
+  private getClipboardFilesWindows(): ClipboardFileResult[] {
+    let filePath: ClipboardFileResult[] = []
+
+    if (clipboard.has('CF_HDROP')) {
+      // Handle multiple files
+      const rawFilePathStr = clipboard.readBuffer('CF_HDROP').toString('ucs2') || ''
+      let formatFilePathStr = [...rawFilePathStr]
+        .filter((_, index) => rawFilePathStr.charCodeAt(index) !== 0)
+        .join('')
+        .replace(/\\/g, '\\\\')
+
+      const drivePrefix = formatFilePathStr.match(/[a-zA-Z]:\\/)
+
+      if (drivePrefix) {
+        const drivePrefixIndex = formatFilePathStr.indexOf(drivePrefix[0])
+        if (drivePrefixIndex !== 0) {
+          formatFilePathStr = formatFilePathStr.substring(drivePrefixIndex)
+        }
+        filePath = formatFilePathStr
+          .split(drivePrefix[0])
+          .filter(item => item)
+          .map(item => drivePrefix[0] + item)
+      }
+    } else {
+      // Handle single file
+      const clipboardImage = clipboard.readImage('clipboard')
+      if (!clipboardImage.isEmpty()) {
+        // Handle image from clipboard
+        const png = clipboardImage.toPNG()
+        const fileInfo: ClipboardFileInfo = {
+          buffer: png,
+          mimetype: 'image/png',
+          originalname: this.generateUuid(8, 16) + '.png'
+        }
+        filePath = [fileInfo]
+      } else {
+        // Handle single file path
+        try {
+          const fileName = clipboard.readBuffer('FileNameW').toString('ucs2').replace(RegExp(String.fromCharCode(0), 'g'), '')
+          if (fileName) {
+            filePath = [fileName]
+          }
+        } catch (error) {
+          // Ignore read errors for non-file clipboard content
+        }
+      }
+    }
+
+    return filePath
+  }
+
+  /**
+   * Retrieves file paths or file information from the system clipboard
+   *
+   * This method handles both file paths and images from the clipboard across different platforms.
+   * On macOS, it uses NSFilenamesPboardType for multiple files and public.file-url for single files.
+   * On Windows, it uses CF_HDROP for multiple files and FileNameW for single files.
+   *
+   * @returns Array of file paths (strings) or file info objects containing buffer data for images
+   * @throws {Error} When clipboard access fails or platform is unsupported
+   *
+   * @example
+   * ```typescript
+   * const clipboardHelper = new ClipboardHelper()
+   * const files = clipboardHelper.getClipboardFiles()
+   *
+   * files.forEach(file => {
+   *   if (typeof file === 'string') {
+   *     console.log('File path:', file)
+   *   } else {
+   *     console.log('Image file:', file.originalname, 'Size:', file.buffer.length)
+   *   }
+   * })
+   * ```
+   */
+  public getClipboardFiles(): ClipboardFileResult[] {
+    try {
+      if (this.isMac) {
+        return this.getClipboardFilesMac()
+      } else {
+        return this.getClipboardFilesWindows()
+      }
+    } catch (error) {
+      console.error('Failed to read clipboard files:', error)
+      return []
+    }
+  }
+}
+
+/**
+ * Default export of ClipboardHelper class for convenience
+ */
+export default ClipboardHelper

package/electron/env-tool.ts

@@ -1,4 +1,5 @@
-import { exec, ExecException } from 'child_process';
+import { exec, ExecException } from 'child_process'
+import { platform } from 'process'
 
 export interface IGlobalPkgResult {
   exist: boolean
@@ -54,4 +55,37 @@ export function getNpmVersion(): Promise<string | null> {
       resolve(stdout.trim())
     })
   })
-}
+}
+
+export interface OSAdapter<R, T> {
+  win32?: (payload: R) => T
+  darwin?: (payload: R) => T
+  linux?: (payload: R) => T
+  /**
+   * Executed before platform-specific functions.
+   * Its return value will be passed as a parameter to the platform-specific function.
+   */
+  onBeforeExecute?: () => R
+}
+
+/**
+ * An adapter function that executes different logic depending on the operating system platform.
+ * @param options An object containing implementations for different platforms.
+ * @returns The execution result of the platform-specific function.
+ */
+export function withOSAdapter<R, T>(options: OSAdapter<R, T>): T | undefined {
+  const payload = options.onBeforeExecute?.()
+
+  const arg = payload as R
+
+  switch (platform) {
+    case 'win32':
+      return options.win32?.(arg)
+    case 'darwin':
+      return options.darwin?.(arg)
+    case 'linux':
+      return options.linux?.(arg)
+    default:
+      return undefined
+  }
+}

package/electron/file-parsers/index.ts

@@ -0,0 +1,8 @@
+import { fileParserRegistry } from './registry'
+import { textFileParser } from './parsers/text-parser'
+
+fileParserRegistry.register(textFileParser)
+
+export * from './types'
+export * from './registry'
+export { textFileParser }

package/electron/file-parsers/parsers/text-parser.ts

@@ -0,0 +1,109 @@
+import fs from 'fs/promises'
+import path from 'path'
+import {
+  FileParser,
+  FileParserContext,
+  FileParserProgress,
+  FileParserResult
+} from '../types'
+
+const TEXTUAL_EXTENSIONS = new Set(
+  [
+    '.txt',
+    '.md',
+    '.rtf',
+    '.json',
+    '.yaml',
+    '.yml',
+    '.xml',
+    '.csv',
+    '.log',
+    '.ini',
+    '.conf',
+    '.env',
+    '.html',
+    '.htm',
+    '.js',
+    '.ts',
+    '.tsx',
+    '.jsx',
+    '.py',
+    '.go',
+    '.rs',
+    '.java',
+    '.kt',
+    '.cs',
+    '.c',
+    '.cpp',
+    '.cc',
+    '.hpp',
+    '.m',
+    '.mm',
+    '.swift',
+    '.php',
+    '.rb',
+    '.sh',
+    '.bash',
+    '.zsh',
+    '.fish',
+    '.bat',
+    '.ps1',
+    '.sql'
+  ].map((ext) => ext.toLowerCase())
+)
+
+export class TextFileParser implements FileParser {
+  readonly id = 'text-file-parser'
+  readonly priority = 100
+  readonly supportedExtensions = TEXTUAL_EXTENSIONS
+
+  async parse(
+    context: FileParserContext,
+    onProgress?: (progress: FileParserProgress) => void
+  ): Promise<FileParserResult> {
+    const { filePath, extension, size, maxBytes } = context
+    if (maxBytes && size > maxBytes) {
+      return {
+        status: 'skipped',
+        reason: 'file-too-large',
+        totalBytes: size,
+        processedBytes: 0,
+        warnings: [
+          `File size ${(size / (1024 * 1024)).toFixed(2)}MB exceeds limit ${(maxBytes / (1024 * 1024)).toFixed(2)}MB`
+        ]
+      }
+    }
+
+    if (!TEXTUAL_EXTENSIONS.has(extension)) {
+      return {
+        status: 'skipped',
+        reason: 'unsupported-extension'
+      }
+    }
+
+    try {
+      const content = await fs.readFile(filePath, 'utf8')
+      if (onProgress) {
+        onProgress({ processedBytes: size, totalBytes: size, percentage: 1 })
+      }
+
+      return {
+        status: 'success',
+        content,
+        metadata: {
+          length: content.length,
+          basename: path.basename(filePath)
+        },
+        processedBytes: size,
+        totalBytes: size
+      }
+    } catch (error) {
+      return {
+        status: 'failed',
+        reason: error instanceof Error ? error.message : 'unknown-error'
+      }
+    }
+  }
+}
+
+export const textFileParser = new TextFileParser()

package/electron/file-parsers/registry.ts

@@ -0,0 +1,92 @@
+import {
+  FileParser,
+  FileParserContext,
+  FileParserProgress,
+  FileParserResult,
+  FileParserSelectionOptions
+} from './types'
+
+interface RegisteredParser {
+  parser: FileParser
+  extensions: Set<string>
+  priority: number
+}
+
+export class FileParserRegistry {
+  private readonly parsers: RegisteredParser[] = []
+
+  register(parser: FileParser): void {
+    const extensions = new Set(
+      Array.from(parser.supportedExtensions).map((ext) => ext.trim().toLowerCase())
+    )
+    if (extensions.size === 0) {
+      throw new Error(`[FileParserRegistry] Parser ${parser.id} registered without extensions`)
+    }
+
+    this.parsers.push({ parser, extensions, priority: parser.priority ?? 0 })
+    this.parsers.sort((a, b) => b.priority - a.priority)
+  }
+
+  unregister(parserId: string): void {
+    const index = this.parsers.findIndex(({ parser }) => parser.id === parserId)
+    if (index >= 0) {
+      this.parsers.splice(index, 1)
+    }
+  }
+
+  getParsersForExtension(extension: string): FileParser[] {
+    if (!extension) return []
+    const normalized = extension.toLowerCase()
+    return this.parsers
+      .filter(({ extensions }) => extensions.has(normalized))
+      .map(({ parser }) => parser)
+  }
+
+  getPreferredParser(extension: string, options?: FileParserSelectionOptions): FileParser | null {
+    const [preferred] = this.getParsersForExtension(extension)
+    if (!preferred && options?.allowFallback) {
+      // Allow fallback to wildcard parsers if they exist in the registry
+      const wildcard = this.parsers.find(({ extensions }) => extensions.has('*'))
+      return wildcard?.parser ?? null
+    }
+    return preferred ?? null
+  }
+
+  async parseWithBestParser(
+    context: FileParserContext,
+    onProgress?: (progress: FileParserProgress) => void
+  ): Promise<FileParserResult | null> {
+    const candidates = this.getParsersForExtension(context.extension)
+    const allParsers = context.extension !== '*' ? candidates : []
+
+    if (context.extension !== '*') {
+      const wildcard = this.getParsersForExtension('*')
+      allParsers.push(...wildcard)
+    }
+
+    for (const parser of allParsers) {
+      if (parser.canParse && !(await parser.canParse(context))) {
+        continue
+      }
+      try {
+        const result = await parser.parse(context, onProgress)
+        if (!result) {
+          continue
+        }
+        if (result.status !== 'skipped') {
+          return result
+        }
+      } catch (error) {
+        console.error(`[FileParserRegistry] Parser ${parser.id} failed:`, error)
+        return {
+          status: 'failed',
+          reason: error instanceof Error ? error.message : 'unknown-error'
+        }
+      }
+    }
+
+    return null
+  }
+}
+
+export const fileParserRegistry = new FileParserRegistry()

package/electron/file-parsers/types.ts

@@ -0,0 +1,58 @@
+export type FileParserStatus = 'success' | 'skipped' | 'failed'
+
+export interface FileParserContext {
+  filePath: string
+  extension: string
+  size: number
+  maxBytes?: number
+  metadata?: Record<string, any>
+  signal?: AbortSignal
+}
+
+export interface FileParserProgress {
+  processedBytes?: number
+  totalBytes?: number
+  percentage?: number
+  message?: string
+}
+
+export interface FileParserEmbedding {
+  provider: string
+  model: string
+  vector: number[]
+  metadata?: Record<string, any>
+}
+
+export interface FileParserResult {
+  status: FileParserStatus
+  content?: string
+  metadata?: Record<string, any>
+  tags?: string[]
+  warnings?: string[]
+  processedBytes?: number
+  totalBytes?: number
+  reason?: string
+  embeddings?: FileParserEmbedding[]
+  durationMs?: number
+}
+
+export interface FileParser {
+  readonly id: string
+  /** Higher priority parsers win when multiple support the same extension */
+  readonly priority?: number
+  readonly supportedExtensions: string[] | Set<string>
+  canParse?(context: FileParserContext): boolean | Promise<boolean>
+  parse(
+    context: FileParserContext,
+    onProgress?: (progress: FileParserProgress) => void
+  ): Promise<FileParserResult>
+}
+
+export interface FileParserSelectionOptions {
+  allowFallback?: boolean
+}
+
+export interface FileParserRegistryOptions {
+  /** When true, registry falls back to lower priority parsers if the preferred one skips */
+  enableFallback?: boolean
+}

package/electron/index.ts

@@ -0,0 +1,3 @@
+export * from './clipboard-helper'
+export * from './download-manager'
+export * from './env-tool'

package/eventbus/index.ts

@@ -70,13 +70,6 @@ export interface ITouchEventBus<E> {
    */
   offAll(event: E): boolean;
 
-  /**
-   * UnSubscribe touch-app events all matched (any kind of events extends from TouchEvent)
-   * @param event EventName (extends from TouchEvent)
-   * @returns true if the event was added, otherwise false
-   */
-  offAll(event: E): boolean;
-
   /**
    * Emit touch-app events (any kind of events extends from TouchEvent)
    * @param event EventName (extends from TouchEvent)

package/index.ts

@@ -3,4 +3,6 @@ export * from './common'
 export * from './plugin'
 export * from './core-box'
 export * from './channel'
-export * from './types'
+export * from './types'
+export * from './eventbus'
+export * from './preload'

package/package.json

@@ -5,53 +5,28 @@
   "module": "./index.ts",
   "license": "MPL-2.0",
   "private": false,
-  "version": "1.0.18",
-  "exports": {
-    ".": "./index.ts",
-    "./types": "./types/index.ts",
-    "./channel": "./channel/index.ts",
-    "./base": "./base/index.ts",
-    "./common": "./common/index.ts",
-    "./common/utils": "./common/utils.ts",
-    "./plugin": "./plugin/index.ts",
-    "./plugin/log/logger-manager": "./plugin/log/logger-manager.ts",
-    "./plugin/log/logger": "./plugin/log/logger.ts",
-    "./plugin/sdk": "./plugin/sdk.ts",
-    "./plugin/sdk/window": "./plugin/sdk/window.ts",
-    "./core-box": "./core-box/index.ts",
-    "./search/types": "./search/types.ts",
-    "./eventbus": "./eventbus/index.ts",
-    "./permission": "./permission/index.ts",
-    "./renderer": "./renderer/index.ts",
-    "./renderer/ref": "./renderer/ref.ts",
-    "./renderer/slots": "./renderer/slots.ts",
-    "./renderer/storage/app-settings": "./renderer/storage/app-settings.ts",
-    "./service": "./service/index.ts",
-    "./service/protocol": "./service/protocol/index.ts",
-    "./electron/env-tool": "./electron/env-tool.ts",
-    "./electron/download-manager": "./electron/download-manager.ts",
-    "./animation/": "./animation/"
-  },
+  "version": "1.0.20",
   "scripts": {
     "publish": "npm publish --access public"
   },
   "keywords": [
     "vue",
     "electron",
+    "launcher",
     "talex-touch"
   ],
   "repository": {
     "url": "https://github.com/talex-touch/talex-touch.git",
     "type": "git"
   },
-  "description": "TalexTouch series utils",
+  "description": "Tuff series utils",
   "dependencies": {
     "@vueuse/core": "^13.6.0",
     "path-browserify": "^1.0.1",
     "vue": "^3.5.18"
   },
   "peerDependencies": {
-    "electron": "^29.4.6",
+    "electron": "^37.2.4",
     "vue": "^3.5.15"
   }
 }