AndroidRemoteController/nodejs/ef-compiler/variable-parser.js

/**
 * 统一解析结点入参、出参：将 action 中的变量引用用 variableContext 解析为实际值。
 * 规则：{var}、{{var}} 为变量（替换为变量值）；{arr}[{idx}]、{arr}[数字] 为数组下标，解析为对应元素；"hello{var}" 为字符串+变量拼接。
 * 所有函数的入参、出参都经本脚本解析后再传给对应结点。
 */
const setParser = require('./actions/set-parser.js')
const resolveValue = setParser.resolveValue
const replaceVariablesInString = setParser.replaceVariablesInString
const extractVarName = setParser.extractVarName

/** 视为入参的字段（会被解析）；inVars 由本脚本统一解析后传给各结点。 */
const INPUT_KEYS = [
  'value', 'target', 'template', 'area', 'savePath', 'condition', 'delay', 'interval',
  'items', 'screenshot', 'region', 'method', 'clear', 'timeout', 'retry',
  'min', 'max', 'avatar1', 'avatar2', 'friendAvatar', 'avatar', 'path', 'filePath',
  'inputDataString', 'textVariable', 'senderVariable', 'appendMode',
  'summaryPrompt', 'historyPrompt', 'model', 'prompt', 'systemPrompt',
  'regionArea', 'saveDir', 'url', 'filename', 'imageUrl',
]

/**
 * 将数组下标取值结果转为可嵌入字符串的形式
 */
function toEmbedString(v) {
  if (v === undefined || v === null) return ''
  if (typeof v === 'string') return v
  if (typeof v === 'number' || typeof v === 'boolean') return String(v)
  try {
    return JSON.stringify(v)
  } catch (e) {
    return String(v)
  }
}

/**
 * 解析字符串中的数组下标：{arr}[{idx}]、{arr}[数字]，替换为实际元素值。
 * 先于普通变量替换执行，以便 {img-prompt-arr}[{idx}] 能解析为当前项。
 */
function replaceArrayIndexInString(str, variableContext) {
  if (typeof str !== 'string' || !variableContext) return str
  // {var}[{indexVar}]
  let out = str.replace(/\{([\w-]+)\}\s*\[\s*\{([\w-]+)\}\s*\]/g, (_, arrName, idxName) => {
    const arr = variableContext[arrName]
    const idxVal = variableContext[idxName]
    if (!Array.isArray(arr)) return toEmbedString(arr)
    const i = typeof idxVal === 'number' ? idxVal : parseInt(idxVal, 10)
    if (Number.isNaN(i) || i < 0 || i >= arr.length) return ''
    return toEmbedString(arr[i])
  })
  // {var}[数字]
  out = out.replace(/\{([\w-]+)\}\s*\[\s*(\d+)\s*\]/g, (_, arrName, numStr) => {
    const arr = variableContext[arrName]
    if (!Array.isArray(arr)) return toEmbedString(arr)
    const i = parseInt(numStr, 10)
    if (i < 0 || i >= arr.length) return ''
    return toEmbedString(arr[i])
  })
  return out
}

/**
 * 解析单值：先解析数组下标 {arr}[{idx}] / {arr}[n]，再做 {{var}}、{var} 替换，最后对整体做引用解析。
 */
function resolveInputValue(val, variableContext) {
  if (variableContext == null) return val
  if (typeof val === 'string') {
    const afterIndex = replaceArrayIndexInString(val, variableContext)
    const replaced = replaceVariablesInString(afterIndex, variableContext)
    let result = resolveValue(replaced, variableContext)
    if (result === val && /^[\w-]+$/.test(val) && variableContext[val] !== undefined) result = variableContext[val]
    return result
  }
  if (Array.isArray(val)) return val.map(item => resolveInputValue(item, variableContext))
  if (typeof val === 'object' && val !== null) {
    const out = {}
    for (const k in val) out[k] = resolveInputValue(val[k], variableContext)
    return out
  }
  return val
}

/**
 * 解析整条 action 的入参，返回新对象（不修改原 action）
 * @param {object} action - 原始或已 parse 的 action
 * @param {object} variableContext - 变量表
 * @returns {object} 入参解析后的 action 副本
 */
function resolveActionInputs(action, variableContext) {
  if (!action || typeof action !== 'object') return action
  if (!variableContext || typeof variableContext !== 'object') return Object.assign({}, action)

  const resolved = Object.assign({}, action)

  for (const key of INPUT_KEYS) {
    if (key in resolved && resolved[key] !== undefined && resolved[key] !== null) {
      resolved[key] = resolveInputValue(resolved[key], variableContext)
    }
  }

  if (resolved.inVars && Array.isArray(resolved.inVars)) {
    resolved.inVars = resolved.inVars.map((v) => resolveInputValue(v, variableContext))
  }
  if (resolved.outVars && Array.isArray(resolved.outVars)) {
    resolved.outVars = resolved.outVars.map((v) => (typeof v === 'string' ? extractVarName(v) : v))
  }

  if (resolved.condition && typeof resolved.condition === 'object' && !Array.isArray(resolved.condition)) {
    const c = resolved.condition
    if (c.interval != null) resolved.condition = Object.assign({}, c, { interval: resolveInputValue(c.interval, variableContext) })
    if (c.repeat != null) resolved.condition = Object.assign({}, resolved.condition, { repeat: resolveInputValue(c.repeat, variableContext) })
  }

  return resolved
}

module.exports = {
  resolveActionInputs,
  resolveInputValue,
  replaceArrayIndexInString,
  extractVarName,
}