sk-voice-command 1.0.0

package/src/plugin.js

@@ -0,0 +1,252 @@
+import CommandMatcher from './core/command-matcher'
+import store from './core/store'
+import { validateConfig } from './utils/helpers'
+import { STATUS, ERROR_CODES, ERROR_MESSAGES } from './utils/constants'
+
+/**
+ * Vue 插件
+ */
+function install(Vue, options = {}) {
+  // 验证配置
+  let config
+  try {
+    config = validateConfig(options)
+  } catch (error) {
+    console.error('[sk-voice-command] 配置错误:', error.message)
+    throw error
+  }
+
+  // 创建指令匹配器
+  const matcher = new CommandMatcher(config)
+
+  // 创建语音命令实例
+  const voiceCommand = {
+    // 配置
+    _config: config,
+    _matcher: matcher,
+    _store: store,
+
+    // ===== 公开 API =====
+
+    /**
+     * 注册指令
+     * @param {Object} options - 选项
+     */
+    registerCommands(options) {
+      const { scope = 'page', commands = [] } = options
+
+      try {
+        this._matcher.registerCommands(scope, commands)
+
+        if (this._config.debug) {
+          console.log('[sk-voice-command] 注册指令:', { scope, commands })
+        }
+      } catch (error) {
+        console.error('[sk-voice-command] 注册指令失败:', error)
+        throw error
+      }
+    },
+
+    /**
+     * 注销指令
+     * @param {string} scope - 作用域
+     */
+    unregisterCommands(scope) {
+      try {
+        // 获取当前页面路径（如果在 uni-app 环境中）
+        const pages = getCurrentPages()
+        const currentPage = pages[pages.length - 1]
+        const route = currentPage ? currentPage.route : ''
+
+        this._matcher.unregisterCommands(scope, route)
+
+        if (this._config.debug) {
+          console.log('[sk-voice-command] 注销指令:', { scope, route })
+        }
+      } catch (error) {
+        console.error('[sk-voice-command] 注销指令失败:', error)
+      }
+    },
+
+    /**
+     * 开始语音识别
+     * @returns {Promise<void>}
+     */
+    async start() {
+      try {
+        if (this._store.state.isRecording) {
+          console.warn('[sk-voice-command] 已经在录音中')
+          return
+        }
+
+        // TODO: 实现真实的录音和识别逻辑
+        // 这里先使用模拟实现
+        this._store.setStatus(STATUS.RECORDING)
+        this._store.setRecording(true)
+        this._store.setError(null)
+
+        if (this._config.debug) {
+          console.log('[sk-voice-command] 开始录音')
+        }
+
+        // 模拟：触发状态变化事件
+        this._store.emit('recording-started')
+      } catch (error) {
+        console.error('[sk-voice-command] 启动失败:', error)
+        this._store.setError(error.message || ERROR_MESSAGES.UNKNOWN_ERROR)
+        this._store.setStatus(STATUS.ERROR)
+        throw error
+      }
+    },
+
+    /**
+     * 停止语音识别
+     * @returns {Promise<Object>} 识别结果
+     */
+    async stop() {
+      try {
+        if (!this._store.state.isRecording) {
+          console.warn('[sk-voice-command] 没有在录音中')
+          return { text: '', matched: false }
+        }
+
+        // TODO: 实现真实的停止逻辑
+        this._store.setRecording(false)
+        this._store.setStatus(STATUS.COMPLETED)
+
+        // 模拟：识别结果
+        const mockText = this._store.state.recognitionText || '测试识别'
+
+        if (this._config.debug) {
+          console.log('[sk-voice-command] 停止录音:', mockText)
+        }
+
+        // 匹配指令
+        const matchResult = this._matcher.match(mockText)
+
+        if (matchResult.matched && matchResult.action === 'auto') {
+          // 自动执行
+          if (this._config.debug) {
+            console.log('[sk-voice-command] 自动执行指令:', matchResult.command)
+          }
+
+          try {
+            const result = this._matcher.executeCommand(matchResult.command)
+            this._store.setCommand({
+              ...matchResult.command,
+              executed: true,
+              result
+            })
+          } catch (error) {
+            console.error('[sk-voice-command] 执行指令失败:', error)
+            this._store.setError(error.message)
+          }
+        }
+
+        this._store.emit('recording-stopped', {
+          text: mockText,
+          matchResult
+        })
+
+        return {
+          text: mockText,
+          ...matchResult
+        }
+      } catch (error) {
+        console.error('[sk-voice-command] 停止失败:', error)
+        this._store.setError(error.message || ERROR_MESSAGES.UNKNOWN_ERROR)
+        this._store.setStatus(STATUS.ERROR)
+        throw error
+      }
+    },
+
+    /**
+     * 手动匹配指令（用于测试）
+     * @param {string} text - 文本
+     * @returns {Object} 匹配结果
+     */
+    matchCommand(text) {
+      const result = this._matcher.match(text)
+
+      if (this._config.debug) {
+        console.log('[sk-voice-command] 匹配指令:', { text, result })
+      }
+
+      return result
+    },
+
+    /**
+     * 执行指令
+     * @param {Object} command - 指令对象
+     * @returns {*} 执行结果
+     */
+    executeCommand(command) {
+      return this._matcher.executeCommand(command)
+    },
+
+    /**
+     * 监听事件
+     * @param {string} event - 事件名称
+     * @param {Function} callback - 回调函数
+     */
+    on(event, callback) {
+      this._store.on(event, callback)
+    },
+
+    /**
+     * 移除监听
+     * @param {string} event - 事件名称
+     * @param {Function} callback - 回调函数
+     */
+    off(event, callback) {
+      this._store.off(event, callback)
+    },
+
+    // ===== 只读属性 =====
+
+    /**
+     * 获取状态（只读）
+     */
+    get state() {
+      return this._store.state
+    },
+
+    /**
+     * 获取配置（只读）
+     */
+    get config() {
+      return { ...this._config }
+    }
+  }
+
+  // 挂载到 Vue 原型
+  Vue.prototype.$voice = voiceCommand
+
+  // 混入生命周期钩子（自动清理页面指令）
+  Vue.mixin({
+    onUnload() {
+      // 页面卸载时自动清除页面指令
+      if (this.$voice && this.$voice._matcher) {
+        const pages = getCurrentPages()
+        const currentPage = pages[pages.length - 1]
+        const route = currentPage ? currentPage.route : ''
+
+        this.$voice._matcher.unregisterCommands('page', route)
+      }
+    }
+  })
+
+  if (config.debug) {
+    console.log('[sk-voice-command] 插件已安装', config)
+  }
+}
+
+// 默认导出插件
+export default { install }
+
+// 导出常量和工具（供高级使用）
+export { STATUS, ERROR_CODES, ERROR_MESSAGES }
+export { CommandMatcher } from './core/command-matcher'
+export { default as store } from './core/store'
+export * from './utils/helpers'
+export * from './utils/leven'

package/src/utils/constants.js

@@ -0,0 +1,73 @@
+/**
+ * 状态常量
+ */
+export const STATUS = {
+  IDLE: 'idle',                // 空闲
+  RECORDING: 'recording',      // 录音中
+  RECOGNIZING: 'recognizing',  // 识别中
+  COMPLETED: 'completed',      // 已完成
+  ERROR: 'error'               // 错误
+}
+
+/**
+ * 默认配置
+ */
+export const DEFAULT_CONFIG = {
+  // 匹配阈值 (0-1)
+  matchThreshold: 0.8,
+  // 确认阈值 (0-1)
+  confirmThreshold: 0.6,
+  // 启用中间结果
+  enableIntermediateResult: true,
+  // 调试模式
+  debug: false,
+  // 录音超时时间（毫秒）
+  recordTimeout: 60000,
+  // 音频格式
+  format: 'pcm',
+  // 采样率
+  sampleRate: 16000
+}
+
+/**
+ * 错误码映射
+ */
+export const ERROR_CODES = {
+  // 权限错误
+  PERMISSION_DENIED: 'PERMISSION_DENIED',
+  PERMISSION_DENIED_ALWAYS: 'PERMISSION_DENIED_ALWAYS',
+
+  // 网络错误
+  NETWORK_ERROR: 'NETWORK_ERROR',
+  TOKEN_EXPIRED: 'TOKEN_EXPIRED',
+  TOKEN_INVALID: 'TOKEN_INVALID',
+  CONNECTION_FAILED: 'CONNECTION_FAILED',
+
+  // 录音错误
+  RECORD_FAILED: 'RECORD_FAILED',
+  RECORD_TIMEOUT: 'RECORD_TIMEOUT',
+
+  // 识别错误
+  RECOGNITION_FAILED: 'RECOGNITION_FAILED',
+  RECOGNITION_TIMEOUT: 'RECOGNITION_TIMEOUT',
+
+  // 其他错误
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+}
+
+/**
+ * 错误信息映射
+ */
+export const ERROR_MESSAGES = {
+  [ERROR_CODES.PERMISSION_DENIED]: '需要麦克风权限才能使用语音功能',
+  [ERROR_CODES.PERMISSION_DENIED_ALWAYS]: '请在系统设置中开启麦克风权限',
+  [ERROR_CODES.NETWORK_ERROR]: '网络连接失败，请检查网络设置',
+  [ERROR_CODES.TOKEN_EXPIRED]: '访问凭证已过期',
+  [ERROR_CODES.TOKEN_INVALID]: '访问凭证无效',
+  [ERROR_CODES.CONNECTION_FAILED]: '连接服务器失败',
+  [ERROR_CODES.RECORD_FAILED]: '录音失败，请检查麦克风',
+  [ERROR_CODES.RECORD_TIMEOUT]: '录音超时',
+  [ERROR_CODES.RECOGNITION_FAILED]: '语音识别失败',
+  [ERROR_CODES.RECOGNITION_TIMEOUT]: '语音识别超时',
+  [ERROR_CODES.UNKNOWN_ERROR]: '发生未知错误'
+}

package/src/utils/helpers.js

@@ -0,0 +1,137 @@
+/**
+ * 格式化时间（毫秒转 MM:SS）
+ * @param {number} ms - 毫秒数
+ * @returns {string} 格式化后的时间字符串
+ */
+export function formatTime(ms) {
+  const totalSeconds = Math.floor(ms / 1000)
+  const minutes = Math.floor(totalSeconds / 60)
+  const seconds = totalSeconds % 60
+
+  return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`
+}
+
+/**
+ * 清理文本
+ * @param {string} text - 待清理的文本
+ * @returns {string} 清理后的文本
+ */
+export function cleanText(text) {
+  if (!text || typeof text !== 'string') return ''
+  return text.trim().replace(/\s+/g, ' ')
+}
+
+/**
+ * 验证指令配置
+ * @param {Object} command - 指令对象
+ * @returns {boolean} 是否有效
+ * @throws {Error} 如果配置无效
+ */
+export function validateCommand(command) {
+  if (!command || typeof command !== 'object') {
+    throw new Error('指令必须是对象')
+  }
+
+  if (!command.id || typeof command.id !== 'string') {
+    throw new Error('指令必须包含 id 字段（字符串）')
+  }
+
+  if (!command.keywords || !Array.isArray(command.keywords)) {
+    throw new Error('指令必须包含 keywords 字段（数组）')
+  }
+
+  if (command.keywords.length === 0) {
+    throw new Error('指令 keywords 不能为空')
+  }
+
+  if (typeof command.action !== 'function') {
+    throw new Error('指令必须包含 action 字段（函数）')
+  }
+
+  return true
+}
+
+/**
+ * 验证配置对象
+ * @param {Object} config - 配置对象
+ * @returns {Object} 验证后的配置（合并默认值）
+ * @throws {Error} 如果配置无效
+ */
+export function validateConfig(config = {}) {
+  const { DEFAULT_CONFIG, ERROR_CODES } = require('./constants')
+
+  if (!config.appkey || typeof config.appkey !== 'string') {
+    throw new Error('必须提供 appkey（字符串）')
+  }
+
+  if (!config.tokenUrl || typeof config.tokenUrl !== 'string') {
+    throw new Error('必须提供 tokenUrl（字符串）')
+  }
+
+  return {
+    ...DEFAULT_CONFIG,
+    ...config
+  }
+}
+
+/**
+ * 防抖函数
+ * @param {Function} func - 要防抖的函数
+ * @param {number} wait - 等待时间（毫秒）
+ * @returns {Function} 防抖后的函数
+ */
+export function debounce(func, wait) {
+  let timeout
+  return function executedFunction(...args) {
+    const later = () => {
+      clearTimeout(timeout)
+      func(...args)
+    }
+    clearTimeout(timeout)
+    timeout = setTimeout(later, wait)
+  }
+}
+
+/**
+ * 节流函数
+ * @param {Function} func - 要节流的函数
+ * @param {number} wait - 等待时间（毫秒）
+ * @returns {Function} 节流后的函数
+ */
+export function throttle(func, wait) {
+  let inThrottle
+  return function executedFunction(...args) {
+    if (!inThrottle) {
+      func(...args)
+      inThrottle = true
+      setTimeout(() => inThrottle = false, wait)
+    }
+  }
+}
+
+/**
+ * 深度克隆对象
+ * @param {*} obj - 要克隆的对象
+ * @returns {*} 克隆后的对象
+ */
+export function deepClone(obj) {
+  if (obj === null || typeof obj !== 'object') return obj
+  if (obj instanceof Date) return new Date(obj.getTime())
+  if (obj instanceof Array) return obj.map(item => deepClone(item))
+
+  const clonedObj = {}
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      clonedObj[key] = deepClone(obj[key])
+    }
+  }
+  return clonedObj
+}
+
+/**
+ * 简单的 ID 生成器
+ * @returns {string} 唯一 ID
+ */
+export function generateId() {
+  return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+}

package/src/utils/leven.js

@@ -0,0 +1,144 @@
+/**
+ * 计算 Levenshtein 距离（编辑距离）
+ * @param {string} str1 - 字符串1
+ * @param {string} str2 - 字符串2
+ * @returns {number} 编辑距离
+ */
+export function levenshteinDistance(str1, str2) {
+  if (!str1 || !str2) return 0
+
+  const m = str1.length
+  const n = str2.length
+
+  // 如果其中一个字符串为空，返回另一个字符串的长度
+  if (m === 0) return n
+  if (n === 0) return m
+
+  // 创建二维数组
+  const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0))
+
+  // 初始化第一行和第一列
+  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 = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (str1[i - 1] === str2[j - 1]) {
+        // 字符相同，不需要操作
+        dp[i][j] = dp[i - 1][j - 1]
+      } else {
+        // 取三种操作的最小值：插入、删除、替换
+        dp[i][j] = Math.min(
+          dp[i - 1][j] + 1,    // 删除
+          dp[i][j - 1] + 1,    // 插入
+          dp[i - 1][j - 1] + 1 // 替换
+        )
+      }
+    }
+  }
+
+  return dp[m][n]
+}
+
+/**
+ * 计算两个字符串的相似度（0-1）
+ * @param {string} str1 - 字符串1
+ * @param {string} str2 - 字符串2
+ * @returns {number} 相似度（0-1之间，1表示完全相同）
+ */
+export function calculateSimilarity(str1, str2) {
+  if (!str1 || !str2) return 0
+  if (str1 === str2) return 1
+
+  const distance = levenshteinDistance(str1, str2)
+  const maxLen = Math.max(str1.length, str2.length)
+
+  if (maxLen === 0) return 1
+
+  // 相似度 = (最大长度 - 编辑距离) / 最大长度
+  return (maxLen - distance) / maxLen
+}
+
+/**
+ * 在多个关键词中找到最佳匹配
+ * @param {string} text - 待匹配的文本
+ * @param {Array<string>} keywords - 关键词数组
+ * @returns {Object} 匹配结果 { keyword, similarity, index }
+ */
+export function findBestMatch(text, keywords) {
+  if (!text || !keywords || keywords.length === 0) {
+    return { keyword: null, similarity: 0, index: -1 }
+  }
+
+  let bestMatch = { keyword: null, similarity: 0, index: -1 }
+
+  keywords.forEach((keyword, index) => {
+    const similarity = calculateSimilarity(text, keyword)
+    if (similarity > bestMatch.similarity) {
+      bestMatch = { keyword, similarity, index }
+    }
+  })
+
+  return bestMatch
+}
+
+/**
+ * 批量计算文本与多个关键词的相似度
+ * @param {string} text - 待匹配的文本
+ * @param {Array<string>} keywords - 关键词数组
+ * @returns {Array<Object>} 相似度结果数组
+ */
+export function calculateAllSimilarities(text, keywords) {
+  if (!text || !keywords || keywords.length === 0) {
+    return []
+  }
+
+  return keywords.map((keyword, index) => ({
+    keyword,
+    similarity: calculateSimilarity(text, keyword),
+    index
+  })).sort((a, b) => b.similarity - a.similarity) // 按相似度降序排序
+}
+
+// 缓存优化（可选）
+const similarityCache = new Map()
+
+/**
+ * 带缓存的相似度计算
+ * @param {string} str1 - 字符串1
+ * @param {string} str2 - 字符串2
+ * @returns {number} 相似度
+ */
+export function calculateSimilarityCached(str1, str2) {
+  if (!str1 || !str2) return 0
+
+  const cacheKey = `${str1}|||${str2}`
+  const reverseKey = `${str2}|||${str1}`
+
+  if (similarityCache.has(cacheKey)) {
+    return similarityCache.get(cacheKey)
+  }
+
+  if (similarityCache.has(reverseKey)) {
+    return similarityCache.get(reverseKey)
+  }
+
+  const similarity = calculateSimilarity(str1, str2)
+  similarityCache.set(cacheKey, similarity)
+
+  // 限制缓存大小（避免内存泄漏）
+  if (similarityCache.size > 1000) {
+    const firstKey = similarityCache.keys().next().value
+    similarityCache.delete(firstKey)
+  }
+
+  return similarity
+}
+
+/**
+ * 清空缓存
+ */
+export function clearSimilarityCache() {
+  similarityCache.clear()
+}