digitalsee-ai-flow-cli 0.1.7 → 0.1.9

package/dist/utils/format.js

@@ -16,25 +16,25 @@ function configSchemaToParams(subParams) {
         name: p.name,
         type: inferFieldType(p),
         required: p.required ?? false,
-        description: sanitizeDescription(p.description || ""),
+        description: sanitizeDescription(p.description || ''),
         display_name: p.display_name || p.name,
         options: normalizeOptionValues(p.option_value_objects ?? p.option_values),
         default: p.value,
     }));
 }
 function sanitizeDescription(desc) {
-    return desc.replace(/\u0000/g, "\\u0000");
+    return desc.replace(/\u0000/g, '\\u0000');
 }
 function normalizeOptionValues(raw) {
     if (!raw || !Array.isArray(raw) || raw.length === 0)
         return undefined;
     return raw
         .map((item) => {
-        if (typeof item === "string") {
+        if (typeof item === 'string') {
             const v = item.trim();
             return v ? { key: v, label: v } : null;
         }
-        const value = String(item?.value ?? item?.label ?? "").trim();
+        const value = String(item?.value ?? item?.label ?? '').trim();
         if (!value)
             return null;
         const label = String(item?.label ?? value).trim() || value;
@@ -49,77 +49,79 @@ function inferFieldType(param) {
     if (param.type) {
         return param.type;
     }
-    return "string";
+    return 'string';
 }
 function inferScenarios(actionName, description) {
     const scenarios = [];
-    const text = `${actionName} ${description || ""}`.toLowerCase();
-    if (text.includes("trigger") || text.includes("webhook")) {
-        scenarios.push("作为流程触发器，在外部事件发生时启动工作流");
+    const text = `${actionName} ${description || ''}`.toLowerCase();
+    if (text.includes('trigger') || text.includes('webhook')) {
+        scenarios.push('作为流程触发器，在外部事件发生时启动工作流');
     }
-    if (text.includes("http") || text.includes("api") || text.includes("rest")) {
-        scenarios.push("调用外部 HTTP API 接口，实现系统间的数据交互");
+    if (text.includes('http') || text.includes('api') || text.includes('rest')) {
+        scenarios.push('调用外部 HTTP API 接口，实现系统间的数据交互');
     }
-    if (text.includes("database") ||
-        text.includes("sql") ||
-        text.includes("mysql") ||
-        text.includes("postgres") ||
-        text.includes("数据")) {
-        scenarios.push("连接数据库，执行数据查询或写入操作");
+    if (text.includes('database') ||
+        text.includes('sql') ||
+        text.includes('mysql') ||
+        text.includes('postgres') ||
+        text.includes('数据')) {
+        scenarios.push('连接数据库，执行数据查询或写入操作');
     }
-    if (text.includes("email") || text.includes("mail") || text.includes("邮件")) {
-        scenarios.push("发送或接收邮件通知");
+    if (text.includes('email') || text.includes('mail') || text.includes('邮件')) {
+        scenarios.push('发送或接收邮件通知');
     }
-    if (text.includes("ai") || text.includes("llm") || text.includes("model")) {
-        scenarios.push("调用 AI 大模型进行文本生成、分析或推理");
+    if (text.includes('ai') || text.includes('llm') || text.includes('model')) {
+        scenarios.push('调用 AI 大模型进行文本生成、分析或推理');
     }
-    if (text.includes("condition") || text.includes("条件")) {
-        scenarios.push("根据条件判断结果进行流程分支控制");
+    if (text.includes('condition') || text.includes('条件')) {
+        scenarios.push('根据条件判断结果进行流程分支控制');
     }
-    if (text.includes("loop") || text.includes("循环")) {
-        scenarios.push("对数据集进行批量循环处理");
+    if (text.includes('loop') || text.includes('循环')) {
+        scenarios.push('对数据集进行批量循环处理');
     }
-    if (text.includes("transform") || text.includes("转换") || text.includes("map")) {
-        scenarios.push("对数据进行格式转换或映射处理");
+    if (text.includes('transform') || text.includes('转换') || text.includes('map')) {
+        scenarios.push('对数据进行格式转换或映射处理');
     }
-    if (text.includes("notification") || text.includes("通知") || text.includes("message")) {
-        scenarios.push("发送消息通知或告警");
+    if (text.includes('notification') || text.includes('通知') || text.includes('message')) {
+        scenarios.push('发送消息通知或告警');
     }
     if (scenarios.length === 0) {
-        scenarios.push("执行自定义业务逻辑操作");
+        scenarios.push('执行自定义业务逻辑操作');
     }
     return scenarios;
 }
 function sanitizeFileName(name) {
     return name
-        .replace(/[<>:"/\\|?*]/g, "_")
-        .replace(/\s+/g, "_")
-        .replace(/^\.+/, "")
+        .replace(/[<>:"/\\|?*]/g, '_')
+        .replace(/\s+/g, '_')
+        .replace(/^\.+/, '')
         .substring(0, 200);
 }
 function fillConfigSchemaDefaults(schema) {
     const clone = JSON.parse(JSON.stringify(schema));
     function walk(node) {
-        if (!node || typeof node !== "object")
+        if (!node || typeof node !== 'object')
             return;
-        if (node.sub_params && Array.isArray(node.sub_params)) {
-            for (const child of node.sub_params) {
-                if (child.value === undefined || child.value === null) {
-                    child.value = inferDefaultValue(child);
+        const n = node;
+        if (n.sub_params && Array.isArray(n.sub_params)) {
+            for (const child of n.sub_params) {
+                const c = child;
+                if (c.value === undefined || c.value === null) {
+                    c.value = inferDefaultValue(c);
                 }
-                child.update = true;
-                walk(child);
+                c.update = true;
+                walk(c);
             }
         }
-        if (node.value === undefined || node.value === null) {
-            if (node.sub_params) {
-                node.value = null;
+        if (n.value === undefined || n.value === null) {
+            if (n.sub_params) {
+                n.value = null;
             }
             else {
-                node.value = inferDefaultValue(node);
+                n.value = inferDefaultValue(n);
             }
         }
-        node.update = true;
+        n.update = true;
     }
     walk(clone);
     return clone;
@@ -127,43 +129,43 @@ function fillConfigSchemaDefaults(schema) {
 function inferDefaultValue(param) {
     if (param.value !== undefined && param.value !== null)
         return param.value;
-    const type = (param.page_control || param.type || "").toUpperCase();
-    if (type === "SELECT") {
+    const type = (param.page_control || param.type || '').toUpperCase();
+    if (type === 'SELECT') {
         if (param.multi_valued)
             return [];
         const options = param.option_value_objects ?? param.option_values;
         if (options && Array.isArray(options) && options.length > 0) {
             const first = options[0];
-            if (typeof first === "string")
+            if (typeof first === 'string')
                 return first;
-            if (typeof first === "object" && first !== null) {
-                return first.value ?? first.label ?? "";
+            if (typeof first === 'object' && first !== null) {
+                return first.value ?? first.label ?? '';
             }
         }
         return null;
     }
     switch (type) {
-        case "NUMBER":
+        case 'NUMBER':
             return 0;
-        case "BOOLEAN":
-        case "SWITCH":
+        case 'BOOLEAN':
+        case 'SWITCH':
             return false;
-        case "DATE":
-        case "TIME":
-        case "DATETIME":
+        case 'DATE':
+        case 'TIME':
+        case 'DATETIME':
             return null;
-        case "JSON":
-            return "{}";
-        case "EXTEND_OBJ":
-        case "FIXED_OBJ":
+        case 'JSON':
+            return '{}';
+        case 'EXTEND_OBJ':
+        case 'FIXED_OBJ':
             return param.sub_params ? null : {};
-        case "TEXTAREA":
-        case "PASSWORD":
-        case "HIDDEN":
-        case "LABEL":
-        case "TEXT":
+        case 'TEXTAREA':
+        case 'PASSWORD':
+        case 'HIDDEN':
+        case 'LABEL':
+        case 'TEXT':
         default:
-            return "";
+            return '';
     }
 }
 function parseVariableRefs(text) {
@@ -174,7 +176,7 @@ function parseVariableRefs(text) {
         refs.push({
             raw: match[0],
             nodeId: match[1],
-            path: match[2] || "",
+            path: match[2] || '',
         });
     }
     return refs;
@@ -182,12 +184,14 @@ function parseVariableRefs(text) {
 function mergeConfigValues(schema, overrides) {
     const clone = JSON.parse(JSON.stringify(schema));
     function walk(node, overrideMap) {
-        if (!node?.sub_params)
+        const n = node;
+        if (!n.sub_params)
             return;
-        for (const child of node.sub_params) {
-            if (child.name && child.name in overrideMap) {
-                const val = overrideMap[child.name];
-                if (child.sub_params && typeof val === "object" && !Array.isArray(val)) {
+        for (const child of n.sub_params) {
+            const childName = child.name;
+            if (childName && childName in overrideMap) {
+                const val = overrideMap[childName];
+                if (child.sub_params && typeof val === 'object' && !Array.isArray(val)) {
                     walk(child, val);
                 }
                 else {
@@ -208,29 +212,30 @@ function mergeConfigValues(schema, overrides) {
 function validateNodePropertyValues(schema) {
     const errors = [];
     function walk(node, path) {
-        if (!node || typeof node !== "object")
+        if (!node || typeof node !== 'object')
             return;
-        if (node.sub_params && Array.isArray(node.sub_params)) {
-            for (const child of node.sub_params) {
-                const childPath = path
-                    ? `${path}.${child.name || "(anonymous)"}`
-                    : (child.name || "(anonymous)");
-                checkField(child, childPath);
-                walk(child, childPath);
+        const n = node;
+        if (n.sub_params && Array.isArray(n.sub_params)) {
+            for (const child of n.sub_params) {
+                const c = child;
+                const cName = String(c.name || '(anonymous)');
+                const childPath = path ? `${path}.${cName}` : cName;
+                checkField(c, childPath);
+                walk(c, childPath);
             }
         }
     }
     function checkField(field, fieldPath) {
         const val = field.value;
-        const pageControl = (field.page_control || field.type || "").toUpperCase();
-        const isEmpty = val === undefined || val === null || val === "";
+        const pageControl = String(field.page_control || field.type || '').toUpperCase();
+        const isEmpty = val === undefined || val === null || val === '';
         // 1. 检查必填字段
         if (field.required && isEmpty) {
             errors.push({
                 field: fieldPath,
-                rule: "required",
+                rule: 'required',
                 message: `必填字段 "${field.display_name} : ${field.name}" 未提供值`,
-                sample: "",
+                sample: '',
             });
         }
         // 2. 如果有值，检查值类型是否匹配 page_control
@@ -241,65 +246,65 @@ function validateNodePropertyValues(schema) {
     function checkTypeConstraint(field, fieldPath, pageControl, val) {
         const sample = JSON.stringify(val).substring(0, 80);
         switch (pageControl) {
-            case "SELECT":
+            case 'SELECT':
                 if (field.multi_valued) {
                     if (!Array.isArray(val)) {
                         errors.push({
                             field: fieldPath,
-                            rule: "type",
+                            rule: 'type',
                             message: `SELECT(multi) 字段 "${field.display_name || field.name}" 期望 array 类型，实际为 ${typeof val}`,
                             sample,
                         });
                     }
                 }
                 else {
-                    if (typeof val !== "string") {
+                    if (typeof val !== 'string') {
                         errors.push({
                             field: fieldPath,
-                            rule: "type",
+                            rule: 'type',
                             message: `SELECT 字段 "${field.display_name || field.name}" 期望 string 类型，实际为 ${typeof val}`,
                             sample,
                         });
                     }
                 }
                 break;
-            case "NUMBER":
-                if (typeof val !== "number") {
+            case 'NUMBER':
+                if (typeof val !== 'number') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `NUMBER 字段 "${field.display_name || field.name}" 期望 number 类型，实际为 ${typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "BOOLEAN":
-            case "SWITCH":
-                if (typeof val !== "boolean") {
+            case 'BOOLEAN':
+            case 'SWITCH':
+                if (typeof val !== 'boolean') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 boolean 类型，实际为 ${typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "EXTEND_OBJ":
-            case "FIXED_OBJ":
-                if (typeof val !== "object" || Array.isArray(val)) {
+            case 'EXTEND_OBJ':
+            case 'FIXED_OBJ':
+                if (typeof val !== 'object' || Array.isArray(val)) {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
-                        message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 object 类型，实际为 ${Array.isArray(val) ? "array" : typeof val}`,
+                        rule: 'type',
+                        message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 object 类型，实际为 ${Array.isArray(val) ? 'array' : typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "JSON":
-                if (typeof val !== "string") {
+            case 'JSON':
+                if (typeof val !== 'string') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `JSON 字段 "${field.display_name || field.name}" 期望 JSON 字符串，实际为 ${typeof val}`,
                         sample,
                     });
@@ -311,34 +316,34 @@ function validateNodePropertyValues(schema) {
                     catch {
                         errors.push({
                             field: fieldPath,
-                            rule: "format",
+                            rule: 'format',
                             message: `JSON 字段 "${field.display_name || field.name}" 的值不是有效的 JSON`,
                             sample: val.substring(0, 80),
                         });
                     }
                 }
                 break;
-            case "DATE":
-            case "TIME":
-            case "DATETIME":
-                if (typeof val !== "string") {
+            case 'DATE':
+            case 'TIME':
+            case 'DATETIME':
+                if (typeof val !== 'string') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `${pageControl} 字段 "${field.display_name || field.name}" 期望日期/时间字符串，实际为 ${typeof val}`,
                         sample,
                     });
                 }
                 break;
-            case "TEXT":
-            case "TEXTAREA":
-            case "PASSWORD":
-            case "HIDDEN":
-            case "LABEL":
-                if (typeof val !== "string") {
+            case 'TEXT':
+            case 'TEXTAREA':
+            case 'PASSWORD':
+            case 'HIDDEN':
+            case 'LABEL':
+                if (typeof val !== 'string') {
                     errors.push({
                         field: fieldPath,
-                        rule: "type",
+                        rule: 'type',
                         message: `${pageControl} 字段 "${field.display_name || field.name}" 期望 string 类型，实际为 ${typeof val}`,
                         sample,
                     });
@@ -348,32 +353,38 @@ function validateNodePropertyValues(schema) {
                 break;
         }
     }
-    walk(schema, "");
+    walk(schema, '');
     return errors;
 }
 const VALID_CONDITION_OPERATORS = new Set([
-    "eq", "ne", "gt", "ge", "lt", "le",
-    "sw", "ew", "co", "nco", "in", "nin",
-    "is_null", "is_not_null",
-]);
-const NULL_OPERATORS = new Set(["is_null", "is_not_null"]);
-const LOOP_TYPES = new Set(["NUMBER", "ARRAY", "CONDITION"]);
-const ERROR_EXEC_OPTIONS = new Set(["END", "CONTINUE", "BREAK"]);
-const SPECIAL_NODE_TYPES = new Set([
-    "ConditionNode",
-    "LoopNode",
-    "SelfLoopNode",
-    "SwitchNode",
+    'eq',
+    'ne',
+    'gt',
+    'ge',
+    'lt',
+    'le',
+    'sw',
+    'ew',
+    'co',
+    'nco',
+    'in',
+    'nin',
+    'is_null',
+    'is_not_null',
 ]);
+const NULL_OPERATORS = new Set(['is_null', 'is_not_null']);
+const LOOP_TYPES = new Set(['NUMBER', 'ARRAY', 'CONDITION']);
+const ERROR_EXEC_OPTIONS = new Set(['END', 'CONTINUE', 'BREAK']);
+const SPECIAL_NODE_TYPES = new Set(['ConditionNode', 'LoopNode', 'SelfLoopNode', 'SwitchNode']);
 function safeSample(val) {
-    return (JSON.stringify(val) ?? "").substring(0, 80);
+    return (JSON.stringify(val) ?? '').substring(0, 80);
 }
 function validateOrList(orList, path) {
     const errors = [];
     if (!Array.isArray(orList)) {
         errors.push({
             field: path,
-            rule: "type",
+            rule: 'type',
             message: `${path} 必须是 array 类型`,
             sample: safeSample(orList),
         });
@@ -382,18 +393,18 @@ function validateOrList(orList, path) {
     if (orList.length === 0) {
         errors.push({
             field: path,
-            rule: "required",
+            rule: 'required',
             message: `${path} 至少需要 1 个条件组`,
-            sample: "",
+            sample: '',
         });
         return errors;
     }
     orList.forEach((orItem, i) => {
         const orPath = `${path}[${i}]`;
-        if (!orItem || typeof orItem !== "object") {
+        if (!orItem || typeof orItem !== 'object') {
             errors.push({
                 field: orPath,
-                rule: "type",
+                rule: 'type',
                 message: `${orPath} 必须是 object 类型`,
                 sample: safeSample(orItem),
             });
@@ -403,7 +414,7 @@ function validateOrList(orList, path) {
         if (!Array.isArray(andList)) {
             errors.push({
                 field: `${orPath}.and_list`,
-                rule: "type",
+                rule: 'type',
                 message: `${orPath}.and_list 必须是 array 类型`,
                 sample: safeSample(andList),
             });
@@ -412,44 +423,44 @@ function validateOrList(orList, path) {
         if (andList.length === 0) {
             errors.push({
                 field: `${orPath}.and_list`,
-                rule: "required",
+                rule: 'required',
                 message: `${orPath}.and_list 至少需要 1 个条件`,
-                sample: "",
+                sample: '',
             });
             return;
         }
         andList.forEach((item, j) => {
             const itemPath = `${orPath}.and_list[${j}]`;
-            if (!item || typeof item !== "object") {
+            if (!item || typeof item !== 'object') {
                 errors.push({
                     field: itemPath,
-                    rule: "type",
+                    rule: 'type',
                     message: `${itemPath} 必须是 object 类型`,
                     sample: safeSample(item),
                 });
                 return;
             }
-            if (!item.query || typeof item.query !== "string" || !item.query.trim()) {
+            if (!item.query || typeof item.query !== 'string' || !item.query.trim()) {
                 errors.push({
                     field: `${itemPath}.query`,
-                    rule: "required",
+                    rule: 'required',
                     message: `${itemPath}.query 是必填字段，须为变量引用`,
-                    sample: "",
+                    sample: '',
                 });
             }
-            if (!item.operator || typeof item.operator !== "string") {
+            if (!item.operator || typeof item.operator !== 'string') {
                 errors.push({
                     field: `${itemPath}.operator`,
-                    rule: "required",
+                    rule: 'required',
                     message: `${itemPath}.operator 是必填字段`,
-                    sample: "",
+                    sample: '',
                 });
             }
             else if (!VALID_CONDITION_OPERATORS.has(item.operator)) {
                 errors.push({
                     field: `${itemPath}.operator`,
-                    rule: "type",
-                    message: `${itemPath}.operator 无效: "${item.operator}"，有效值: ${[...VALID_CONDITION_OPERATORS].join(", ")}`,
+                    rule: 'type',
+                    message: `${itemPath}.operator 无效: "${item.operator}"，有效值: ${[...VALID_CONDITION_OPERATORS].join(', ')}`,
                     sample: item.operator,
                 });
             }
@@ -458,9 +469,9 @@ function validateOrList(orList, path) {
                 (item.value === undefined || item.value === null)) {
                 errors.push({
                     field: `${itemPath}.value`,
-                    rule: "required",
+                    rule: 'required',
                     message: `${itemPath}.value 在运算符为 "${item.operator}" 时必须提供`,
-                    sample: "",
+                    sample: '',
                 });
             }
         });
@@ -477,22 +488,22 @@ function validateSpecialNodeType(nodeType, data) {
     const props = data.properties || {};
     const errors = [];
     switch (nodeType) {
-        case "ConditionNode": {
+        case 'ConditionNode': {
             if (props.or_list === undefined || props.or_list === null) {
                 errors.push({
-                    field: "properties.or_list",
-                    rule: "required",
-                    message: "ConditionNode 缺少必填字段 properties.or_list",
-                    sample: "",
+                    field: 'properties.or_list',
+                    rule: 'required',
+                    message: 'ConditionNode 缺少必填字段 properties.or_list',
+                    sample: '',
                 });
             }
             else {
-                errors.push(...validateOrList(props.or_list, "properties.or_list"));
+                errors.push(...validateOrList(props.or_list, 'properties.or_list'));
             }
             break;
         }
-        case "LoopNode":
-        case "SelfLoopNode": {
+        case 'LoopNode':
+        case 'SelfLoopNode': {
             // LoopNode 字段在 properties 下双份存在：直接属性 + sub_params[].value
             // CLI --data 只填充 sub_params，API 返回时两者都有，需要从两处查找
             const loopField = (name) => {
@@ -506,125 +517,125 @@ function validateSpecialNodeType(nodeType, data) {
                 }
                 return undefined;
             };
-            const loopType = loopField("type");
+            const loopType = loopField('type');
             if (!loopType || !LOOP_TYPES.has(loopType)) {
                 errors.push({
-                    field: "properties.type",
-                    rule: "required",
+                    field: 'properties.type',
+                    rule: 'required',
                     message: `循环节点 properties.type 必须是 NUMBER / ARRAY / CONDITION 之一，当前为 "${loopType}"`,
-                    sample: loopType ? String(loopType) : "",
+                    sample: loopType || '',
                 });
             }
-            if (loopType === "NUMBER") {
-                const startVal = loopField("start");
-                const endVal = loopField("end");
-                if (typeof startVal !== "number") {
+            if (loopType === 'NUMBER') {
+                const startVal = loopField('start');
+                const endVal = loopField('end');
+                if (typeof startVal !== 'number') {
                     errors.push({
-                        field: "properties.start",
-                        rule: "type",
+                        field: 'properties.start',
+                        rule: 'type',
                         message: `NUMBER 循环的 properties.start 必须是 number 类型，当前为 ${typeof startVal}`,
                         sample: String(startVal),
                     });
                 }
                 else if (startVal < 1) {
                     errors.push({
-                        field: "properties.start",
-                        rule: "type",
+                        field: 'properties.start',
+                        rule: 'type',
                         message: `NUMBER 循环的 properties.start 必须 >= 1，当前为 ${startVal}`,
                         sample: String(startVal),
                     });
                 }
-                if (typeof endVal !== "number") {
+                if (typeof endVal !== 'number') {
                     errors.push({
-                        field: "properties.end",
-                        rule: "type",
+                        field: 'properties.end',
+                        rule: 'type',
                         message: `NUMBER 循环的 properties.end 必须是 number 类型，当前为 ${typeof endVal}`,
                         sample: String(endVal),
                     });
                 }
-                else if (typeof startVal === "number" && endVal < startVal) {
+                else if (typeof startVal === 'number' && endVal < startVal) {
                     errors.push({
-                        field: "properties.end",
-                        rule: "type",
+                        field: 'properties.end',
+                        rule: 'type',
                         message: `NUMBER 循环的 properties.end (${endVal}) 必须 >= properties.start (${startVal})`,
                         sample: String(endVal),
                     });
                 }
             }
-            if (loopType === "ARRAY" || loopType === "CONDITION") {
-                const exprVal = loopField("expression");
-                if (!exprVal || typeof exprVal !== "string" || !exprVal.trim()) {
+            if (loopType === 'ARRAY' || loopType === 'CONDITION') {
+                const exprVal = loopField('expression');
+                if (!exprVal || typeof exprVal !== 'string' || !exprVal.trim()) {
                     errors.push({
-                        field: "properties.expression",
-                        rule: "required",
+                        field: 'properties.expression',
+                        rule: 'required',
                         message: `${loopType} 循环的 properties.expression 是必填字段`,
-                        sample: exprVal ? String(exprVal).substring(0, 80) : "",
+                        sample: exprVal ? String(exprVal).substring(0, 80) : '',
                     });
                 }
             }
-            const ascVal = loopField("asc");
-            if (typeof ascVal !== "boolean") {
+            const ascVal = loopField('asc');
+            if (typeof ascVal !== 'boolean') {
                 errors.push({
-                    field: "properties.asc",
-                    rule: "type",
+                    field: 'properties.asc',
+                    rule: 'type',
                     message: `properties.asc 必须是 boolean 类型，当前为 ${typeof ascVal}`,
                     sample: String(ascVal),
                 });
             }
-            const errExecVal = loopField("errorExec");
+            const errExecVal = loopField('errorExec');
             if (!errExecVal || !ERROR_EXEC_OPTIONS.has(errExecVal)) {
                 errors.push({
-                    field: "properties.errorExec",
-                    rule: "required",
+                    field: 'properties.errorExec',
+                    rule: 'required',
                     message: `properties.errorExec 必须是 END / CONTINUE / BREAK 之一，当前为 "${errExecVal}"`,
-                    sample: errExecVal ? String(errExecVal) : "",
+                    sample: errExecVal ? String(errExecVal) : '',
                 });
             }
             break;
         }
-        case "SwitchNode": {
+        case 'SwitchNode': {
             const branches = props.branches;
             if (!Array.isArray(branches)) {
                 errors.push({
-                    field: "properties.branches",
-                    rule: "type",
+                    field: 'properties.branches',
+                    rule: 'type',
                     message: `properties.branches 必须是 array 类型，当前为 ${typeof branches}`,
                     sample: safeSample(branches),
                 });
             }
             else if (branches.length < 2 || branches.length > 10) {
                 errors.push({
-                    field: "properties.branches",
-                    rule: "type",
+                    field: 'properties.branches',
+                    rule: 'type',
                     message: `properties.branches 需要 2-10 个分支，当前为 ${branches.length} 个`,
-                    sample: "",
+                    sample: '',
                 });
             }
             else {
                 const seenIds = new Set();
                 branches.forEach((branch, i) => {
                     const brPath = `properties.branches[${i}]`;
-                    if (!branch || typeof branch !== "object") {
+                    if (!branch || typeof branch !== 'object') {
                         errors.push({
                             field: brPath,
-                            rule: "type",
+                            rule: 'type',
                             message: `${brPath} 必须是 object 类型`,
                             sample: safeSample(branch),
                         });
                         return;
                     }
-                    if (!branch.id || typeof branch.id !== "string" || !branch.id.trim()) {
+                    if (!branch.id || typeof branch.id !== 'string' || !branch.id.trim()) {
                         errors.push({
                             field: `${brPath}.id`,
-                            rule: "required",
+                            rule: 'required',
                             message: `${brPath}.id 是必填字段`,
-                            sample: "",
+                            sample: '',
                         });
                     }
                     else if (seenIds.has(branch.id)) {
                         errors.push({
                             field: `${brPath}.id`,
-                            rule: "type",
+                            rule: 'type',
                             message: `分支 id "${branch.id}" 重复`,
                             sample: branch.id,
                         });
@@ -632,20 +643,20 @@ function validateSpecialNodeType(nodeType, data) {
                     else {
                         seenIds.add(branch.id);
                     }
-                    if (!branch.name || typeof branch.name !== "string" || !branch.name.trim()) {
+                    if (!branch.name || typeof branch.name !== 'string' || !branch.name.trim()) {
                         errors.push({
                             field: `${brPath}.name`,
-                            rule: "required",
+                            rule: 'required',
                             message: `${brPath}.name 是必填字段`,
-                            sample: "",
+                            sample: '',
                         });
                     }
                     if (!branch.or_list) {
                         errors.push({
                             field: `${brPath}.or_list`,
-                            rule: "required",
+                            rule: 'required',
                             message: `${brPath}.or_list 是必填字段`,
-                            sample: "",
+                            sample: '',
                         });
                     }
                     else {
@@ -660,18 +671,20 @@ function validateSpecialNodeType(nodeType, data) {
 }
 function isPlainObject(value) {
     return (value !== null &&
-        typeof value === "object" &&
+        typeof value === 'object' &&
         !Array.isArray(value) &&
-        Object.prototype.toString.call(value) === "[object Object]");
+        Object.prototype.toString.call(value) === '[object Object]');
 }
 function deepMerge(target, ...sources) {
+    const tgt = target;
     for (const source of sources) {
-        if (source == null || typeof source !== "object" || Array.isArray(source)) {
+        if (source == null || typeof source !== 'object' || Array.isArray(source)) {
             continue;
         }
-        const subParams = target.sub_params;
-        for (const key of Object.keys(source)) {
-            const srcVal = source[key];
+        const src = source;
+        const subParams = tgt.sub_params;
+        for (const key of Object.keys(src)) {
+            const srcVal = src[key];
             // sub_params-aware merge: 匹配 name 并原地修改 target 的 sub_params 中的 value
             if (Array.isArray(subParams)) {
                 const matched = subParams.find((item) => item.name === key);
@@ -685,15 +698,16 @@ function deepMerge(target, ...sources) {
                     continue;
                 }
             }
-            const tgtVal = target[key];
+            const tgtVal = tgt[key];
             // sub_params 数组按 name 合并，避免整体替换导致数据丢失
-            if (key === "sub_params" && Array.isArray(tgtVal) && Array.isArray(srcVal)) {
+            if (key === 'sub_params' && Array.isArray(tgtVal) && Array.isArray(srcVal)) {
+                const tgtArr = tgtVal;
                 for (const srcItem of srcVal) {
-                    if (!srcItem || typeof srcItem.name !== "string") {
-                        tgtVal.push(srcItem);
+                    if (!srcItem || typeof srcItem.name !== 'string') {
+                        tgtArr.push(srcItem);
                         continue;
                     }
-                    const matched = tgtVal.find((t) => t.name === srcItem.name);
+                    const matched = tgtArr.find((t) => t.name === srcItem.name);
                     if (matched) {
                         if (matched.sub_params && isPlainObject(srcItem.value)) {
                             deepMerge(matched, srcItem.value);
@@ -705,15 +719,15 @@ function deepMerge(target, ...sources) {
                             matched.update = srcItem.update;
                     }
                     else {
-                        tgtVal.push(srcItem);
+                        tgtArr.push(srcItem);
                     }
                 }
             }
             else if (isPlainObject(tgtVal) && isPlainObject(srcVal)) {
-                target[key] = deepMerge({ ...tgtVal }, srcVal);
+                tgt[key] = deepMerge({ ...tgtVal }, srcVal);
             }
             else {
-                target[key] = srcVal;
+                tgt[key] = srcVal;
             }
         }
     }