vue2-client 1.22.2 → 1.22.3

package/.history/src/logic/LogicRunner_20260304154306.js

@@ -0,0 +1,170 @@
+import ServiceException from '../expression/exception/ServiceException'
+import LogicConsole from '../expression/instances/LogicConsole'
+import ExpressionRunner from '../expression/ExpressionRunner'
+import { getLogicConfigByNameAsync } from '@vue2-client/services/api/common'
+import * as Plugins from './plugins/index'
+import Expression from '../expression/core/Expression'
+
+export default class LogicRunner {
+  static logicConsoleInstance = new LogicConsole()
+
+  // 存储正在运行的 Logic 任务，key 为 logicName，value 为 { promise, abortController }
+  static runningTasks = new Map()
+
+  // 缓存 Logic 配置请求，key 为 logicName，value 为 Promise
+  static logicConfigCache = new Map()
+
+  /**
+   * 是否存在指定名称的Logic资源
+   *
+   * @param logicName Logic名称
+   * @return 是否存在
+   */
+  static async has (logicName) {
+    const result = await LogicRunner.getLogic(logicName, false)
+    return result != null
+  }
+
+  /**
+   * 执行Logic
+   *
+   * @param logicName      Logic名称
+   * @param param          参数
+   * @param mode           运行模式：undefined-普通模式，'ignore'-忽略重复，'cancel'-取消前一个
+   * @return 执行结果
+   */
+  static async run (logicName, param, mode) {
+    const taskKey = logicName
+
+    // 模式1: ignore - 如果已存在运行中的任务，直接忽略当前调用
+    if (mode === 'ignore') {
+      if (LogicRunner.runningTasks.has(taskKey)) {
+        console.log(`[LogicRunner] ${logicName} 已在运行中，忽略本次调用`)
+        return null
+      }
+    }
+
+    // 模式2: cancel - 如果已存在运行中的任务，中止之前的任务
+    if (mode === 'cancel') {
+      const existingTask = LogicRunner.runningTasks.get(taskKey)
+      if (existingTask && existingTask.abortController) {
+        console.log(`[LogicRunner] 取消 ${logicName} 的前一次运行`)
+        existingTask.abortController.abort()
+      }
+    }
+
+    // 创建 AbortController 用于支持取消功能
+    const abortController = new AbortController()
+    const taskPromise = LogicRunner.executeLogic(logicName, param, abortController)
+
+    // 存储任务信息
+    LogicRunner.runningTasks.set(taskKey, { promise: taskPromise, abortController })
+
+    try {
+      const result = await taskPromise
+      return result
+    } finally {
+      // 任务完成后移除（如果是 cancel 模式，可能已经被新的任务覆盖）
+      const currentTask = LogicRunner.runningTasks.get(taskKey)
+      if (currentTask && currentTask.promise === taskPromise) {
+        LogicRunner.runningTasks.delete(taskKey)
+      }
+    }
+  }
+
+  /**
+   * 实际执行 Logic 的内部方法
+   */
+  static async executeLogic (logicName, param, abortController) {
+    // 获取Logic资源（带缓存，避免重复请求）
+    const cachedConfig = LogicRunner.logicConfigCache.get(logicName)
+    let result
+    
+    if (cachedConfig) {
+      // 使用缓存的配置
+      result = await cachedConfig
+    } else {
+      // 发起新请求并缓存
+      const configPromise = LogicRunner.getLogic(logicName, false)
+      LogicRunner.logicConfigCache.set(logicName, configPromise)
+      result = await configPromise
+    }
+    
+    if (!result || !result.source) {
+      throw new ServiceException('Logic资源' + logicName + '未找到', 400)
+    }
+    // 预处理 source：移除换行符，将换行替换为分号，避免解析器报错
+    const source = result.source.replace(/[\r\n]+/g, ';')
+    const paramStr = Expression.toJSONString(param)
+    const logicLog = LogicConsole.createLogger('logic.' + logicName)
+    logicLog.info(`执行Logic[${logicName}]，params: ${paramStr}`)
+    // 附加用户注册的对象到业务逻辑中
+    const plugins = {}
+    plugins.data = param
+    plugins.log = logicLog
+    plugins.ENV = result.$globalProp
+    plugins.logic = this
+    // 注入 abortSignal 到 plugins，用于支持取消操作
+    plugins.abortSignal = abortController.signal
+    Object.assign(plugins, Plugins.default)
+    
+    // 使用 Promise 包装执行，以便监听 abort 信号
+    return new Promise((resolve, reject) => {
+      // 监听 abort 信号
+      const abortHandler = () => {
+        const error = new Error(`Logic[${logicName}] 被取消`)
+        error.name = 'AbortError'
+        reject(error)
+      }
+      
+      if (abortController.signal.aborted) {
+        abortHandler()
+        return
+      }
+      
+      abortController.signal.addEventListener('abort', abortHandler)
+      
+      // 执行表达式
+      LogicRunner.runExpression(source, plugins)
+        .then(result => {
+          abortController.signal.removeEventListener('abort', abortHandler)
+          resolve(result)
+        })
+        .catch(error => {
+          abortController.signal.removeEventListener('abort', abortHandler)
+          // 如果是 abort 错误，不再重复抛出（避免 console 显示 unhandled promise rejection）
+          if (error.name === 'AbortError') {
+            return
+          }
+          reject(error)
+        })
+    })
+  }
+
+  /**
+   * 执行原生表达式
+   *
+   * @param source 表达式内容
+   * @param params 参数
+   * @return 执行结果
+   */
+  static async runExpression (source, params) {
+    return await ExpressionRunner.run(source, params)
+  }
+
+  static async getLogic (logicName, isDev) {
+    return await getLogicConfigByNameAsync(logicName, undefined, isDev)
+  }
+
+  /**
+   * 清除指定 Logic 的缓存
+   */
+  static clearCache (logicName) {
+    if (logicName) {
+      LogicRunner.logicConfigCache.delete(logicName)
+    } else {
+      // 清除所有缓存
+      LogicRunner.logicConfigCache.clear()
+    }
+  }
+}

package/.history/src/logic/LogicRunner_20260304155553.js

@@ -0,0 +1,112 @@
+import ServiceException from '../expression/exception/ServiceException'
+import LogicConsole from '../expression/instances/LogicConsole'
+import ExpressionRunner from '../expression/ExpressionRunner'
+import { getLogicConfigByNameAsync } from '@vue2-client/services/api/common'
+import * as Plugins from './plugins/index'
+import Expression from '../expression/core/Expression'
+
+export default class LogicRunner {
+  static logicConsoleInstance = new LogicConsole()
+
+  // 存储正在运行的 Logic 任务，key 为 logicName，value 为 { promise, abortController }
+  static runningTasks = new Map()
+
+  /**
+   * 是否存在指定名称的Logic资源
+   *
+   * @param logicName Logic名称
+   * @return 是否存在
+   */
+  static async has (logicName) {
+    const result = await LogicRunner.getLogic(logicName, false)
+    return result != null
+  }
+
+  /**
+   * 执行Logic
+   *
+   * @param logicName      Logic名称
+   * @param param          参数
+   * @param mode           运行模式：undefined-普通模式，'ignore'-忽略重复，'cancel'-取消前一个
+   * @return 执行结果
+   */
+  static async run (logicName, param, mode) {
+    const taskKey = logicName
+
+    // 模式1: ignore - 如果已存在运行中的任务，直接忽略当前调用
+    if (mode === 'ignore') {
+      if (LogicRunner.runningTasks.has(taskKey)) {
+        console.log(`[LogicRunner] ${logicName} 已在运行中，忽略本次调用`)
+        return null
+      }
+    }
+
+    // 模式2: cancel - 如果已存在运行中的任务，中止之前的任务
+    if (mode === 'cancel') {
+      const existingTask = LogicRunner.runningTasks.get(taskKey)
+      if (existingTask && existingTask.abortController) {
+        console.log(`[LogicRunner] 取消 ${logicName} 的前一次运行`)
+        existingTask.abortController.abort()
+      }
+    }
+
+    // 创建 AbortController 用于支持取消功能
+    const abortController = new AbortController()
+    const taskPromise = LogicRunner.executeLogic(logicName, param, abortController)
+
+    // 存储任务信息
+    LogicRunner.runningTasks.set(taskKey, { promise: taskPromise, abortController })
+
+    try {
+      const result = await taskPromise
+      return result
+    } finally {
+      // 任务完成后移除（如果是 cancel 模式，可能已经被新的任务覆盖）
+      const currentTask = LogicRunner.runningTasks.get(taskKey)
+      if (currentTask && currentTask.promise === taskPromise) {
+        LogicRunner.runningTasks.delete(taskKey)
+      }
+    }
+  }
+
+  /**
+   * 实际执行 Logic 的内部方法
+   */
+  static async executeLogic (logicName, param, abortController) {
+    // 获取Logic资源（传 shouldParseConfig: false，不触发服务端解析）
+    const result = await LogicRunner.getLogic(logicName, false)
+    if (!result || !result.source) {
+      throw new ServiceException('Logic资源' + logicName + '未找到', 400)
+    }
+    // 预处理 source：移除换行符，将换行替换为分号，避免解析器报错
+    const source = result.source.replace(/[\r\n]+/g, ';')
+    const paramStr = Expression.toJSONString(param)
+    const logicLog = LogicConsole.createLogger('logic.' + logicName)
+    logicLog.info(`执行Logic[${logicName}]，params: ${paramStr}`)
+    // 附加用户注册的对象到业务逻辑中
+    const plugins = {}
+    plugins.data = param
+    plugins.log = logicLog
+    plugins.ENV = result.$globalProp
+    plugins.logic = this
+    // 注入 abortSignal 到 plugins，用于支持取消操作
+    plugins.abortSignal = abortController.signal
+    Object.assign(plugins, Plugins.default)
+    return LogicRunner.runExpression(source, plugins)
+  }
+
+  /**
+   * 执行原生表达式
+   *
+   * @param source 表达式内容
+   * @param params 参数
+   * @return 执行结果
+   */
+  static async runExpression (source, params) {
+    return await ExpressionRunner.run(source, params)
+  }
+
+  static async getLogic (logicName, isDev) {
+    return await getLogicConfigByNameAsync(logicName, undefined, isDev)
+  }
+}

package/.history/src/logic/LogicRunner_20260305105834.js

@@ -0,0 +1,112 @@
+import ServiceException from '../expression/exception/ServiceException'
+import LogicConsole from '../expression/instances/LogicConsole'
+import ExpressionRunner from '../expression/ExpressionRunner'
+import { getLogicConfigByNameAsync } from '@vue2-client/services/api/common'
+import * as Plugins from './plugins/index'
+import Expression from '../expression/core/Expression'
+
+export default class LogicRunner {
+  static logicConsoleInstance = new LogicConsole()
+
+  // 存储正在运行的 Logic 任务，key 为 logicName，value 为 { promise, abortController }
+  static runningTasks = new Map()
+
+  /**
+   * 是否存在指定名称的Logic资源
+   *
+   * @param logicName Logic名称
+   * @return 是否存在
+   */
+  static async has (logicName) {
+    const result = await LogicRunner.getLogic(logicName, false)
+    return result != null
+  }
+
+  /**
+   * 执行Logic
+   *
+   * @param logicName      Logic名称
+   * @param param          参数
+   * @param mode           运行模式：undefined-普通模式，'ignore'-忽略重复，'cancel'-取消前一个
+   * @return 执行结果
+   */
+  static async run (logicName, param, mode) {
+    const taskKey = logicName
+
+    // 模式1: ignore - 如果已存在运行中的任务，直接忽略当前调用
+    if (mode === 'ignore') {
+      if (LogicRunner.runningTasks.has(taskKey)) {
+        console.log(`[LogicRunner] ${logicName} 已在运行中，忽略本次调用`)
+        return null
+      }
+    }
+
+    // 模式2: cancel - 如果已存在运行中的任务，中止之前的任务
+    if (mode === 'cancel') {
+      const existingTask = LogicRunner.runningTasks.get(taskKey)
+      if (existingTask && existingTask.abortController) {
+        console.log(`[LogicRunner] 取消 ${logicName} 的前一次运行`)
+        existingTask.abortController.abort()
+      }
+    }
+
+    // 创建 AbortController 用于支持取消功能
+    const abortController = new AbortController()
+    const taskPromise = LogicRunner.executeLogic(logicName, param, abortController)
+
+    // 存储任务信息
+    LogicRunner.runningTasks.set(taskKey, { promise: taskPromise, abortController })
+
+    try {
+      const result = await taskPromise
+      return result
+    } finally {
+      // 任务完成后移除（如果是 cancel 模式，可能已经被新的任务覆盖）
+      const currentTask = LogicRunner.runningTasks.get(taskKey)
+      if (currentTask && currentTask.promise === taskPromise) {
+        LogicRunner.runningTasks.delete(taskKey)
+      }
+    }
+  }
+
+  /**
+   * 实际执行 Logic 的内部方法
+   */
+  static async executeLogic (logicName, param, abortController) {
+    // 获取Logic资源（传 shouldParseConfig: false，不触发服务端解析）
+    const result = await LogicRunner.getLogic(logicName, false)
+    if (!result || !result.source) {
+      throw new ServiceException('Logic资源' + logicName + '未找到', 400)
+    }
+    // 预处理 source：移除换行符，将换行替换为分号，避免解析器报错
+    const source = result.source.replace(/[\r\n]+/g, ';')
+    const paramStr = Expression.toJSONString(param)
+    const logicLog = LogicConsole.createLogger('logic.' + logicName)
+    logicLog.info(`执行Logic[${logicName}]，params: ${paramStr}`)
+    // 附加用户注册的对象到业务逻辑中
+    const plugins = {}
+    plugins.data = param
+    plugins.log = logicLog
+    plugins.ENV = result.$globalProp
+    plugins.logic = this
+    // 注入 abortSignal 到 plugins，用于支持取消操作
+    plugins.abortSignal = abortController.signal
+    Object.assign(plugins, Plugins.default)
+    return LogicRunner.runExpression(source, plugins)
+  }
+
+  /**
+   * 执行原生表达式
+   *
+   * @param source 表达式内容
+   * @param params 参数
+   * @return 执行结果
+   */
+  static async runExpression (source, params) {
+    return await ExpressionRunner.run(source, params)
+  }
+
+  static async getLogic (logicName, isDev) {
+    return await getLogicConfigByNameAsync(logicName, undefined, isDev)
+  }
+}

package/.history/src/logic/LogicRunner_20260305112718.js

@@ -0,0 +1,129 @@
+import ServiceException from '../expression/exception/ServiceException'
+import LogicConsole from '../expression/instances/LogicConsole'
+import ExpressionRunner from '../expression/ExpressionRunner'
+import { getLogicConfigByNameAsync } from '@vue2-client/services/api/common'
+import * as Plugins from './plugins/index'
+import Expression from '../expression/core/Expression'
+
+export default class LogicRunner {
+  static logicConsoleInstance = new LogicConsole()
+
+  // 存储正在运行的 Logic 任务，key 为 logicName，value 为 { promise, abortController, status }
+  // status: 'running' - 运行中, 'completed' - 已完成(用于ignore模式判断)
+  static runningTasks = new Map()
+
+  // 任务完成后保持"已完成"状态的时间(毫秒)，之后自动清理
+  static COMPLETED_STATUS_TTL = 3000
+
+  /**
+   * 是否存在指定名称的Logic资源
+   *
+   * @param logicName Logic名称
+   * @return 是否存在
+   */
+  static async has (logicName) {
+    const result = await LogicRunner.getLogic(logicName, false)
+    return result != null
+  }
+
+  /**
+   * 执行Logic
+   *
+   * @param logicName      Logic名称
+   * @param param          参数
+   * @param mode           运行模式：undefined-普通模式，'ignore'-忽略重复，'cancel'-取消前一个
+   * @return 执行结果
+   */
+  static async run (logicName, param, mode) {
+    const taskKey = logicName
+
+    // 检查已存在的任务
+    const existingTask = LogicRunner.runningTasks.get(taskKey)
+
+    // 模式1: ignore - 如果已存在运行中的任务，直接忽略当前调用
+    if (mode === 'ignore') {
+      // 如果任务正在运行中，忽略本次调用
+      if (existingTask && existingTask.status === 'running') {
+        console.log(`[LogicRunner] ${logicName} 已在运行中，忽略本次调用`)
+        return null
+      }
+    }
+
+    // 模式2: cancel - 如果已存在运行中的任务，中止之前的任务
+    if (mode === 'cancel') {
+      if (existingTask && existingTask.status === 'running') {
+        console.log(`[LogicRunner] 取消 ${logicName} 的前一次运行`)
+        if (existingTask.abortController) {
+          existingTask.abortController.abort()
+        }
+      }
+    }
+
+    // 创建 AbortController 用于支持取消功能
+    const abortController = new AbortController()
+    const taskPromise = LogicRunner.executeLogic(logicName, param, abortController)
+
+    // 存储任务信息，设置状态为运行中
+    LogicRunner.runningTasks.set(taskKey, { promise: taskPromise, abortController, status: 'running' })
+
+    try {
+      const result = await taskPromise
+      return result
+    } finally {
+      // 任务完成后更新状态为已完成，而不是直接删除
+      const currentTask = LogicRunner.runningTasks.get(taskKey)
+      if (currentTask && currentTask.promise === taskPromise) {
+        currentTask.status = 'completed'
+
+        // 延迟删除任务，让 ignore 模式可以检测到"刚完成"的状态
+        setTimeout(() => {
+          const task = LogicRunner.runningTasks.get(taskKey)
+          if (task && task.status === 'completed') {
+            LogicRunner.runningTasks.delete(taskKey)
+          }
+        }, LogicRunner.COMPLETED_STATUS_TTL)
+      }
+    }
+  }
+
+  /**
+   * 实际执行 Logic 的内部方法
+   */
+  static async executeLogic (logicName, param, abortController) {
+    // 获取Logic资源（传 shouldParseConfig: false，不触发服务端解析）
+    const result = await LogicRunner.getLogic(logicName, false)
+    if (!result || !result.source) {
+      throw new ServiceException('Logic资源' + logicName + '未找到', 400)
+    }
+    // 预处理 source：移除换行符，将换行替换为分号，避免解析器报错
+    const source = result.source.replace(/[\r\n]+/g, ';')
+    const paramStr = Expression.toJSONString(param)
+    const logicLog = LogicConsole.createLogger('logic.' + logicName)
+    logicLog.info(`执行Logic[${logicName}]，params: ${paramStr}`)
+    // 附加用户注册的对象到业务逻辑中
+    const plugins = {}
+    plugins.data = param
+    plugins.log = logicLog
+    plugins.ENV = result.$globalProp
+    plugins.logic = this
+    // 注入 abortSignal 到 plugins，用于支持取消操作
+    plugins.abortSignal = abortController.signal
+    Object.assign(plugins, Plugins.default)
+    return LogicRunner.runExpression(source, plugins)
+  }
+
+  /**
+   * 执行原生表达式
+   *
+   * @param source 表达式内容
+   * @param params 参数
+   * @return 执行结果
+   */
+  static async runExpression (source, params) {
+    return await ExpressionRunner.run(source, params)
+  }
+
+  static async getLogic (logicName, isDev) {
+    return await getLogicConfigByNameAsync(logicName, undefined, isDev)
+  }
+}

package/.history/src/logic/LogicRunner_20260305182436.js

@@ -0,0 +1,133 @@
+import ServiceException from '../expression/exception/ServiceException'
+import LogicConsole from '../expression/instances/LogicConsole'
+import ExpressionRunner from '../expression/ExpressionRunner'
+import { getLogicConfigByNameAsync } from '@vue2-client/services/api/common'
+import * as Plugins from './plugins/index'
+import Expression from '../expression/core/Expression'
+
+export default class LogicRunner {
+  static logicConsoleInstance = new LogicConsole()
+
+  // 存储正在运行的 Logic 任务，key 为 logicName，value 为 { promise, abortController, status }
+  // status: 'running' - 运行中, 'completed' - 已完成(用于ignore模式判断)
+  static runningTasks = new Map()
+
+  // 任务完成后保持"已完成"状态的时间(毫秒)，之后自动清理
+  static COMPLETED_STATUS_TTL = 3000
+
+  /**
+   * 是否存在指定名称的Logic资源
+   *
+   * @param logicName Logic名称
+   * @return 是否存在
+   */
+  static async has (logicName) {
+    const result = await LogicRunner.getLogic(logicName, false)
+    return result != null
+  }
+
+  /**
+   * 执行Logic
+   *
+   * @param logicName      Logic名称
+   * @param param          参数
+   * @param mode           运行模式：undefined-普通模式，'ignore'-忽略重复，'cancel'-取消前一个
+   * @return 执行结果
+   */
+  static async run (logicName, param, mode) {
+    const taskKey = logicName
+
+    // 检查已存在的任务
+    const existingTask = LogicRunner.runningTasks.get(taskKey)
+
+    // 模式1: ignore - 如果已存在运行中的任务，直接忽略当前调用
+    if (mode === 'ignore') {
+      // 如果任务正在运行中，忽略本次调用
+      if (existingTask && existingTask.status === 'running') {
+        console.log(`[LogicRunner] ${logicName} 已在运行中，忽略本次调用`)
+        return null
+      }
+    }
+
+    // 模式2: cancel - 如果已存在运行中的任务，中止之前的任务
+    if (mode === 'cancel') {
+      if (existingTask && existingTask.status === 'running') {
+        console.log(`[LogicRunner] 取消 ${logicName} 的前一次运行`)
+        if (existingTask.abortController) {
+          existingTask.abortController.abort()
+        }
+      }
+    }
+
+    // 创建 AbortController 用于支持取消功能
+    const abortController = new AbortController()
+    const taskPromise = LogicRunner.executeLogic(logicName, param, abortController)
+
+    // 存储任务信息，设置状态为运行中
+    LogicRunner.runningTasks.set(taskKey, { promise: taskPromise, abortController, status: 'running' })
+
+    try {
+      const result = await taskPromise
+      return result
+    } finally {
+      // 任务完成后更新状态为已完成，而不是直接删除
+      const currentTask = LogicRunner.runningTasks.get(taskKey)
+      if (currentTask && currentTask.promise === taskPromise) {
+        currentTask.status = 'completed'
+
+        // 延迟删除任务，让 ignore 模式可以检测到"刚完成"的状态
+        setTimeout(() => {
+          const task = LogicRunner.runningTasks.get(taskKey)
+          if (task && task.status === 'completed') {
+            LogicRunner.runningTasks.delete(taskKey)
+          }
+        }, LogicRunner.COMPLETED_STATUS_TTL)
+      }
+    }
+  }
+
+  /**
+   * 实际执行 Logic 的内部方法
+   */
+  static async executeLogic (logicName, param, abortController) {
+    // 获取Logic资源（传 shouldParseConfig: false，不触发服务端解析）
+    const result = await LogicRunner.getLogic(logicName, false)
+    if (!result || !result.source) {
+      throw new ServiceException('Logic资源' + logicName + '未找到', 400)
+    }
+    // 预处理 source：移除换行符，将换行替换为分号，避免解析器报错
+    const source = result.source.replace(/[\r\n]+/g, '')
+    const paramStr = Expression.toJSONString(param)
+    const logicLog = LogicConsole.createLogger('logic.' + logicName)
+    logicLog.info(`执行Logic[${logicName}]，params: ${paramStr}`)
+    // 附加用户注册的对象到业务逻辑中
+    const plugins = {}
+    plugins.data = param
+    plugins.log = logicLog
+    plugins.ENV = result.$globalProp
+    plugins.logic = this
+
+    // 注入 abortSignal 到 plugins，用于支持取消操作
+    console.log('[LogicRunner.executeLogic] 设置 abortSignal:', abortController.signal)
+    plugins.abortSignal = abortController.signal
+
+    Object.assign(plugins, Plugins.default)
+
+    return await LogicRunner.runExpression(source, plugins)
+  }
+
+  /**
+   * 执行原生表达式
+   *
+   * @param source 表达式内容
+   * @param params 参数
+   * @return 执行结果
+   */
+  static async runExpression (source, params) {
+    return await ExpressionRunner.run(source, params)
+  }
+
+  static async getLogic (logicName, isDev) {
+    return await getLogicConfigByNameAsync(logicName, undefined, isDev)
+  }
+}