sk-voice-command 1.0.0

package/src/core/command-matcher.js

@@ -0,0 +1,293 @@
+import { findBestMatch } from '../utils/leven'
+import { validateCommand } from '../utils/helpers'
+import { DEFAULT_CONFIG } from '../utils/constants'
+
+/**
+ * 指令匹配引擎
+ */
+class CommandMatcher {
+  constructor(config = {}) {
+    this.config = {
+      matchThreshold: DEFAULT_CONFIG.matchThreshold,
+      confirmThreshold: DEFAULT_CONFIG.confirmThreshold,
+      ...config
+    }
+
+    // 全局指令
+    this.globalCommands = new Map()
+
+    // 页面指令（使用路由路径作为 key）
+    this.pageCommands = new Map()
+
+    // 当前路由路径
+    this.currentRoute = ''
+  }
+
+  /**
+   * 注册指令
+   * @param {string} scope - 作用域 ('global' | 'page')
+   * @param {Array<Object>} commands - 指令数组
+   * @throws {Error} 如果指令配置无效
+   */
+  registerCommands(scope, commands) {
+    if (scope !== 'global' && scope !== 'page') {
+      throw new Error('作用域必须是 global 或 page')
+    }
+
+    if (!Array.isArray(commands)) {
+      throw new Error('指令必须是数组')
+    }
+
+    // 验证所有指令
+    commands.forEach(cmd => validateCommand(cmd))
+
+    if (scope === 'global') {
+      // 注册全局指令
+      commands.forEach(cmd => {
+        this.globalCommands.set(cmd.id, cmd)
+      })
+    } else {
+      // 注册页面指令
+      const routeKey = this.currentRoute || 'default'
+      const pageCmds = this.pageCommands.get(routeKey) || []
+
+      // 合并指令（相同 id 的会被覆盖）
+      const cmdMap = new Map()
+      pageCmds.forEach(cmd => cmdMap.set(cmd.id, cmd))
+      commands.forEach(cmd => cmdMap.set(cmd.id, cmd))
+
+      this.pageCommands.set(routeKey, Array.from(cmdMap.values()))
+    }
+  }
+
+  /**
+   * 注销指令
+   * @param {string} scope - 作用域
+   * @param {string} route - 路由（页面作用域时使用）
+   */
+  unregisterCommands(scope, route) {
+    if (scope === 'global') {
+      this.globalCommands.clear()
+    } else if (scope === 'page') {
+      const routeKey = route || this.currentRoute || 'default'
+      this.pageCommands.delete(routeKey)
+    }
+  }
+
+  /**
+   * 设置当前路由
+   * @param {string} route - 路由路径
+   */
+  setCurrentRoute(route) {
+    this.currentRoute = route
+  }
+
+  /**
+   * 获取当前可用的所有指令
+   * @returns {Array<Object>} 指令数组
+   */
+  getAllCommands() {
+    const routeKey = this.currentRoute || 'default'
+    const pageCmds = this.pageCommands.get(routeKey) || []
+
+    // 合并页面指令和全局指令
+    // 页面指令优先级更高，所以放在前面
+    return [...pageCmds, ...Array.from(this.globalCommands.values())]
+  }
+
+  /**
+   * 获取所有关键词（包含权重）
+   * @returns {Array<{keyword: string, command: Object, weight: number}>} 关键词数组
+   */
+  getAllKeywords() {
+    const commands = this.getAllCommands()
+    const keywords = []
+
+    commands.forEach(cmd => {
+      if (cmd.keywords && Array.isArray(cmd.keywords)) {
+        cmd.keywords.forEach(keyword => {
+          keywords.push({
+            keyword,
+            command: cmd,
+            weight: cmd.weight || 0 // 默认权重为 0
+          })
+        })
+      }
+    })
+
+    return keywords
+  }
+
+  /**
+   * 匹配指令（支持权重）
+   * @param {string} text - 识别的文本
+   * @returns {Object} 匹配结果
+   */
+  match(text) {
+    if (!text || typeof text !== 'string') {
+      return {
+        matched: false,
+        command: null,
+        similarity: 0,
+        action: 'none'
+      }
+    }
+
+    const keywords = this.getAllKeywords()
+
+    if (keywords.length === 0) {
+      return {
+        matched: false,
+        command: null,
+        similarity: 0,
+        action: 'none'
+      }
+    }
+
+    // 计算所有关键词的相似度
+    const matches = keywords.map(k => ({
+      ...k,
+      similarity: this._calculateSimilarity(text, k.keyword)
+    }))
+
+    // 过滤出超过确认阈值的匹配项
+    const validMatches = matches.filter(m => m.similarity >= this.config.confirmThreshold)
+
+    if (validMatches.length === 0) {
+      return {
+        matched: false,
+        command: null,
+        similarity: 0,
+        action: 'none'
+      }
+    }
+
+    // 找出最佳匹配（考虑权重）
+    const bestMatch = this._findBestMatchWithWeight(validMatches)
+
+    const command = bestMatch.command
+    const similarity = bestMatch.similarity
+    let action = 'none'
+
+    // 判断操作类型
+    if (similarity >= this.config.matchThreshold) {
+      // 高相似度，自动执行
+      action = 'auto'
+    } else if (similarity >= this.config.confirmThreshold) {
+      // 中等相似度，需要确认
+      action = 'confirm'
+    } else {
+      // 低相似度，不执行
+      action = 'reject'
+    }
+
+    return {
+      matched: action !== 'reject',
+      command,
+      similarity,
+      action,
+      matchedKeyword: bestMatch.keyword,
+      weight: bestMatch.weight,
+      allMatches: validMatches.map(m => ({
+        keyword: m.keyword,
+        similarity: m.similarity,
+        weight: m.weight,
+        commandId: m.command.id
+      }))
+    }
+  }
+
+  /**
+   * 计算两个字符串的相似度
+   * @private
+   */
+  _calculateSimilarity(text1, text2) {
+    const { calculateSimilarity } = require('../utils/leven')
+    return calculateSimilarity(text1, text2)
+  }
+
+  /**
+   * 在多个匹配项中找出最佳匹配（考虑权重）
+   * @private
+   */
+  _findBestMatchWithWeight(matches) {
+    if (matches.length === 0) return null
+    if (matches.length === 1) return matches[0]
+
+    // 按相似度降序排序
+    matches.sort((a, b) => b.similarity - a.similarity)
+
+    const highestSimilarity = matches[0].similarity
+
+    // 找出所有相似度与最高相似度差异 <= 5% 的匹配项
+    const similarMatches = matches.filter(
+      m => (highestSimilarity - m.similarity) <= 0.05
+    )
+
+    if (similarMatches.length === 1) {
+      // 只有一个最高相似度项，直接返回
+      return similarMatches[0]
+    }
+
+    // 有多个相似度相近的项，按权重排序
+    similarMatches.sort((a, b) => b.weight - a.weight)
+
+    // 返回权重最高的（如果权重相同，返回第一个，也就是相似度最高的）
+    return similarMatches[0]
+  }
+
+  /**
+   * 执行指令
+   * @param {Object} command - 指令对象
+   * @returns {*} 执行结果
+   */
+  executeCommand(command) {
+    if (!command || typeof command.action !== 'function') {
+      throw new Error('无效的指令对象')
+    }
+
+    try {
+      return command.action()
+    } catch (error) {
+      console.error('执行指令失败:', error)
+      throw error
+    }
+  }
+
+  /**
+   * 获取统计信息
+   * @returns {Object} 统计信息
+   */
+  getStats() {
+    const routeKey = this.currentRoute || 'default'
+    const pageCmds = this.pageCommands.get(routeKey) || []
+
+    return {
+      globalCommandsCount: this.globalCommands.size,
+      pageCommandsCount: pageCmds.length,
+      totalCommandsCount: pageCmds.length + this.globalCommands.size,
+      currentRoute: this.currentRoute
+    }
+  }
+
+  /**
+   * 清空所有指令
+   */
+  clear() {
+    this.globalCommands.clear()
+    this.pageCommands.clear()
+  }
+
+  /**
+   * 更新配置
+   * @param {Object} config - 新配置
+   */
+  updateConfig(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    }
+  }
+}
+
+export default CommandMatcher

package/src/core/store.js

@@ -0,0 +1,263 @@
+import Vue from 'vue'
+import { STATUS } from '../utils/constants'
+
+/**
+ * 创建响应式状态
+ */
+const state = Vue.observable({
+  // 录音状态
+  isRecording: false,
+  // 识别文本
+  recognitionText: '',
+  // 最后执行的指令
+  lastCommand: null,
+  // 错误信息
+  error: null,
+  // 当前状态
+  status: STATUS.IDLE,
+  // 录音时长（毫秒）
+  recordDuration: 0,
+  // 是否正在识别
+  isRecognizing: false
+})
+
+/**
+ * 事件监听器映射表
+ */
+const eventListeners = new Map()
+
+/**
+ * 触发事件
+ * @param {string} event - 事件名称
+ * @param {*} data - 事件数据
+ */
+function emit(event, data) {
+  const listeners = eventListeners.get(event) || []
+  listeners.forEach(callback => {
+    try {
+      callback(data)
+    } catch (error) {
+      console.error(`事件监听器错误 [${event}]:`, error)
+    }
+  })
+}
+
+/**
+ * Store 对象
+ */
+const store = {
+  // 状态对象（只读）
+  state,
+
+  // ===== Mutations =====
+
+  /**
+   * 设置录音状态
+   * @param {boolean} isRecording - 是否正在录音
+   */
+  setRecording(isRecording) {
+    state.isRecording = isRecording
+    emit('recording-change', isRecording)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 设置识别文本
+   * @param {string} text - 识别文本
+   */
+  setText(text) {
+    state.recognitionText = text
+    emit('text-change', text)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 设置状态
+   * @param {string} status - 状态值
+   */
+  setStatus(status) {
+    state.status = status
+    emit('status-change', status)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 设置最后执行的指令
+   * @param {Object} command - 指令对象
+   */
+  setCommand(command) {
+    state.lastCommand = command
+    emit('command-change', command)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 设置错误信息
+   * @param {Error|string} error - 错误信息
+   */
+  setError(error) {
+    state.error = error
+    emit('error-change', error)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 设置录音时长
+   * @param {number} duration - 时长（毫秒）
+   */
+  setDuration(duration) {
+    state.recordDuration = duration
+    emit('duration-change', duration)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 设置识别状态
+   * @param {boolean} isRecognizing - 是否正在识别
+   */
+  setRecognizing(isRecognizing) {
+    state.isRecognizing = isRecognizing
+    emit('recognizing-change', isRecognizing)
+    emit('state-change', { ...state })
+  },
+
+  /**
+   * 重置状态
+   */
+  reset() {
+    state.isRecording = false
+    state.recognitionText = ''
+    state.lastCommand = null
+    state.error = null
+    state.status = STATUS.IDLE
+    state.recordDuration = 0
+    state.isRecognizing = false
+    emit('reset')
+    emit('state-change', { ...state })
+  },
+
+  // ===== Getters =====
+
+  /**
+   * 获取状态
+   * @returns {Object} 状态对象
+   */
+  getState() {
+    return { ...state }
+  },
+
+  /**
+   * 是否正在录音
+   * @returns {boolean}
+   */
+  isRecording() {
+    return state.isRecording
+  },
+
+  /**
+   * 是否正在识别
+   * @returns {boolean}
+   */
+  isRecognizing() {
+    return state.isRecognizing
+  },
+
+  /**
+   * 是否空闲
+   * @returns {boolean}
+   */
+  isIdle() {
+    return state.status === STATUS.IDLE
+  },
+
+  /**
+   * 是否有错误
+   * @returns {boolean}
+   */
+  hasError() {
+    return state.error !== null
+  },
+
+  // ===== Event System =====
+
+  /**
+   * 监听事件
+   * @param {string} event - 事件名称
+   * @param {Function} callback - 回调函数
+   */
+  on(event, callback) {
+    if (typeof callback !== 'function') {
+      throw new Error('回调必须是函数')
+    }
+
+    if (!eventListeners.has(event)) {
+      eventListeners.set(event, [])
+    }
+
+    eventListeners.get(event).push(callback)
+  },
+
+  /**
+   * 移除事件监听
+   * @param {string} event - 事件名称
+   * @param {Function} callback - 回调函数
+   */
+  off(event, callback) {
+    if (!eventListeners.has(event)) return
+
+    const listeners = eventListeners.get(event)
+    const index = listeners.indexOf(callback)
+
+    if (index > -1) {
+      listeners.splice(index, 1)
+    }
+
+    // 如果没有监听器了，删除该事件
+    if (listeners.length === 0) {
+      eventListeners.delete(event)
+    }
+  },
+
+  /**
+   * 移除所有事件监听
+   * @param {string} event - 事件名称（可选，不传则移除所有）
+   */
+  removeAllListeners(event) {
+    if (event) {
+      eventListeners.delete(event)
+    } else {
+      eventListeners.clear()
+    }
+  },
+
+  /**
+   * 获取事件监听器数量
+   * @param {string} event - 事件名称（可选）
+   * @returns {number} 监听器数量
+   */
+  listenerCount(event) {
+    if (event) {
+      return (eventListeners.get(event) || []).length
+    }
+    let total = 0
+    for (const listeners of eventListeners.values()) {
+      total += listeners.length
+    }
+    return total
+  }
+}
+
+// 支持调试模式
+if (process.env.NODE_ENV === 'development') {
+  Object.defineProperty(store, '__debug__', {
+    get() {
+      return {
+        state: { ...state },
+        listeners: Object.fromEntries(eventListeners),
+        listenerCount: store.listenerCount()
+      }
+    }
+  })
+}
+
+export default store

package/src/index.js

@@ -0,0 +1,17 @@
+/**
+ * sk-voice-command - 阿里云语音识别指令模块
+ * 主入口文件
+ */
+
+import plugin from './plugin'
+
+// 默认导出 Vue 插件
+export default plugin
+
+// 导出版本号
+export const version = '1.0.0'
+
+// 导出工具函数和常量
+export * from './utils/constants'
+export * from './utils/helpers'
+export * from './utils/leven'