vue2-client 1.22.21 → 1.22.22

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

@@ -1,170 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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)
-  }
-}