lan-low-code-cli 2.6.0 → 2.8.0

package/dist/commands/operation.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerOperationCommand = registerOperationCommand;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const flow_1 = require("../api/flow");
 const operation_1 = require("../api/operation");
 const view_1 = require("../api/view");
 const client_1 = require("../client");
@@ -18,12 +19,16 @@ const KIND_ALIAS = {
     js: 'script',
     dialog: 'dialog',
     modal: 'dialog',
+    flow: 'flow',
 };
 const KIND_META = {
     link: { fdType: 2, fdViewType: 4, label: '打开链接' },
     script: { fdType: 3, fdViewType: 5, label: '执行脚本' },
     dialog: { fdType: 3, fdViewType: 1, label: '执行业务操作（对话框）' },
+    flow: { fdType: 3, fdViewType: 1, label: '触发动作流' },
 };
+/** 动作流 fdTriggerModel.fdModelName（addOperationModal/content.tsx:981-985） */
+const FLOW_MODEL_NAME = 'com.landray.sys.modeling.process.entity.SysModelingProcess';
 /** 解析 fdConfig（后端实体不一定有顶层 fdViewType，视图类型存在 fdConfig 中） */
 function readOperationConfig(op) {
     if (!op.fdConfig)
@@ -43,7 +48,10 @@ function operationTypeLabel(op) {
         return '对话框';
     if (op.fdType === 6)
         return 'AI 能力';
-    const viewType = Number(readOperationConfig(op).fdViewType ?? op.fdViewType);
+    const config = readOperationConfig(op);
+    if (op.fdType === 3 && Number(config.fdTriggerType) === 3)
+        return '触发动作流';
+    const viewType = Number(config.fdViewType ?? op.fdViewType);
     if (op.fdType === 3)
         return viewType === 5 ? '脚本' : '无视图';
     return '有视图';
@@ -212,19 +220,22 @@ function assertOperationCode(code) {
         throw new Error('--code 需以字母开头，仅允许字母、数字、下划线、连字符');
     }
 }
-/** 从已有操作推导类型（fdType=2 为链接；fdType=3 + fdViewType=5 为脚本，其余按对话框） */
+/** 从已有操作推导类型（fdType=2 链接；fdTriggerType=3 动作流；fdViewType=5 脚本；其余对话框） */
 function detectKind(op) {
     if (op.fdType === 2)
         return 'link';
-    const viewType = Number(readOperationConfig(op).fdViewType ?? op.fdViewType);
+    const config = readOperationConfig(op);
+    if (op.fdType === 3 && Number(config.fdTriggerType) === 3)
+        return 'flow';
+    const viewType = Number(config.fdViewType ?? op.fdViewType);
     return op.fdType === 3 && viewType === 5 ? 'script' : 'dialog';
 }
-function buildCreatePayload(opts) {
+function buildCreatePayload(opts, flow) {
     const formId = String(opts.formId ?? '').trim();
     const name = String(opts.name ?? '').trim();
     const code = String(opts.code ?? '').trim();
     const rawKind = String(opts.type ?? '').trim().toLowerCase();
-    const kind = KIND_ALIAS[rawKind];
+    const kind = opts.triggerFlow ? 'flow' : KIND_ALIAS[rawKind];
     const positionRaw = String(opts.position ?? 'list').trim().toLowerCase();
     const fdPosition = positionRaw === 'view' ? 2 : positionRaw === 'list' ? 1 : 0;
     if (!formId)
@@ -232,7 +243,10 @@ function buildCreatePayload(opts) {
     assertOperationName(name);
     assertOperationCode(code);
     if (!kind)
-        throw new Error(`未知 --type：${opts.type}（可选 link | script | dialog）`);
+        throw new Error(`请指定 --type（link | script | dialog）或 --trigger-flow <动作流 fdId>`);
+    if (opts.triggerFlow && rawKind) {
+        throw new Error('--trigger-flow 与 --type 不能同时使用；触发动作流请省略 --type');
+    }
     if (!fdPosition)
         throw new Error(`未知 --position：${opts.position}（可选 list | view）`);
     const desc = opts.desc === undefined ? '' : String(opts.desc);
@@ -264,6 +278,31 @@ function buildCreatePayload(opts) {
             throw new Error('--type script 需指定 --script <代码|@文件>');
         config.fdJavaScript = readScriptValue(script);
     }
+    else if (kind === 'flow') {
+        if (!flow)
+            throw new Error('--trigger-flow 需要先加载动作流详情');
+        assertTriggerableFlow(flow);
+        config.fdTriggerType = 3;
+        config.fdTriggerId = flow.fdId;
+        config.fdTriggerCode = flow.fdCode;
+        config.fdTriggerModel = {
+            fdId: flow.fdId,
+            fdName: flow.fdName,
+            fdModelName: FLOW_MODEL_NAME,
+            fdCode: flow.fdCode,
+        };
+        const incParams = buildIncParams(opts.incParams);
+        if (incParams !== undefined)
+            config.incParams = incParams;
+        const active = flow.fdProcessActive ?? {};
+        if (active.fdFormId) {
+            // 动作流绑定了表单：按钮按当前文档 id/ids 传参
+            config.incParams = [{
+                    field: { name: active.fdDataType === 2 ? 'fdIds' : 'fdId' },
+                    value: { val: '${fdId}' },
+                }];
+        }
+    }
     else {
         const dialogId = String(opts.dialogId ?? '').trim();
         if (!dialogId)
@@ -288,19 +327,54 @@ function buildCreatePayload(opts) {
         payload.isModal = true;
     return { payload, kind };
 }
+/**
+ * 只有「主动触发 + 已启用 + 允许操作触发」的动作流才能挂到按钮上
+ * （addOperationModal/content.tsx:332-335）。
+ */
+function assertTriggerableFlow(flow) {
+    if (flow.fdStartWay !== 'StartActiveNode') {
+        throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 的启动方式是 ${flow.fdStartWay ?? '(空)'}，只有 StartActiveNode 才能挂到按钮`);
+    }
+    if (flow.fdStatus !== 1) {
+        throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 当前状态为 ${flow.fdStatus ?? '(空)'}，请先发布并启用（llc flow enable --id ${flow.fdId}）`);
+    }
+    const active = flow.fdProcessActive ?? {};
+    if (active.fdOperateTrigger !== true) {
+        throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 未开启「操作触发」，请在 trigger.fdRunType 中包含 operate 后重新发布`);
+    }
+}
+/** --inc-params 支持 @file 或内联 JSON；返回平台要求的 [{field:{name},value:{val}}] */
+function buildIncParams(input) {
+    if (input === undefined || input === null || input === '')
+        return undefined;
+    const raw = typeof input === 'string' ? readScriptValue(input) : JSON.stringify(input);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`--inc-params 不是合法 JSON：${err.message}`);
+    }
+    if (!Array.isArray(parsed))
+        throw new Error('--inc-params 需为数组：[{field:{name},value:{val}}]');
+    return parsed;
+}
 /**
  * 基于现有操作构造 update 请求体。
  * 显式切换类型（--type）时会重建 fdConfig 的类型相关字段，
  * 但保留权限、默认值等与类型无关的配置。
  */
-function buildUpdatePayload(current, opts) {
+function buildUpdatePayload(current, opts, flow) {
     if (current.fdType !== 2 && current.fdType !== 3) {
-        throw new Error(`该操作类型为「${operationTypeLabel(current)}」，仅支持修改自定义的链接 / 脚本 / 对话框操作`);
+        throw new Error(`该操作类型为「${operationTypeLabel(current)}」，仅支持修改自定义的链接 / 脚本 / 对话框 / 动作流操作`);
     }
     const currentKind = detectKind(current);
     const rawKind = String(opts.type ?? '').trim().toLowerCase();
     let kind = currentKind;
-    if (rawKind) {
+    if (opts.triggerFlow) {
+        kind = 'flow';
+    }
+    else if (rawKind) {
         const resolved = KIND_ALIAS[rawKind];
         if (!resolved)
             throw new Error(`未知 --type：${opts.type}（可选 link | script | dialog）`);
@@ -353,6 +427,23 @@ function buildUpdatePayload(current, opts) {
             throw new Error('脚本操作需指定 --script <代码|@文件>');
         config.fdJavaScript = script;
     }
+    else if (kind === 'flow') {
+        if (!flow)
+            throw new Error('--trigger-flow 需要先加载动作流详情');
+        assertTriggerableFlow(flow);
+        config.fdTriggerType = 3;
+        config.fdTriggerId = flow.fdId;
+        config.fdTriggerCode = flow.fdCode;
+        config.fdTriggerModel = {
+            fdId: flow.fdId,
+            fdName: flow.fdName,
+            fdModelName: FLOW_MODEL_NAME,
+            fdCode: flow.fdCode,
+        };
+        const incParams = buildIncParams(opts.incParams);
+        if (incParams !== undefined)
+            config.incParams = incParams;
+    }
     else {
         const dialogId = opts.dialogId !== undefined
             ? String(opts.dialogId).trim()
@@ -397,6 +488,14 @@ function buildUpdatePayload(current, opts) {
         payload.isModal = true;
     else
         delete payload.isModal;
+    if (kind === 'flow') {
+        // 切换为动作流时清理对话框残留字段
+        delete config.fdModal;
+        delete config.fdModalType;
+        delete config.fdModalSizeType;
+        delete config.fdModalDetail;
+        payload.fdConfig = JSON.stringify(config);
+    }
     if (opts.mobileIcon !== undefined)
         payload.fdMobileIcon = String(opts.mobileIcon);
     if (opts.enable === true)
@@ -504,16 +603,18 @@ function registerOperationCommand(program) {
     // ---------------------------------------------------------------- create
     operation
         .command('create')
-        .description('新建业务操作（支持打开链接 / 执行脚本 / 执行对话框）')
+        .description('新建业务操作（打开链接 / 执行脚本 / 执行对话框 / 触发动作流）')
         .requiredOption('--form-id <fdId>', '表单 id')
         .requiredOption('--name <name>', '操作名称（≤30）')
         .requiredOption('--code <code>', '自定义操作编码（≤15，字母开头，可含数字/下划线/连字符）')
-        .requiredOption('--type <type>', '类型：link | script | dialog')
+        .option('--type <type>', '类型：link | script | dialog；触发动作流时改用 --trigger-flow')
         .option('--position <position>', '使用位置：list（列表视图）| view（查看视图）', 'list')
         .option('--need-select', '点击前需勾选数据（默认否；仅列表视图的自定义操作有效）')
         .option('--url <url>', '打开链接地址（--type link 必填）')
         .option('--script <code|@file>', '脚本内容或 @文件（--type script 必填）')
         .option('--dialog-id <fdId>', '对话框 id（--type dialog 必填，可在平台对话框设计中获取）')
+        .option('--trigger-flow <fdId>', '绑定动作流（需 StartActiveNode + 已启用 + operateTrigger）')
+        .option('--inc-params <json|@file>', '动作流入参：[{field:{name},value:{val}}]')
         .option('--desc <text>', '描述（≤500）')
         .option('--mobile-icon <name>', '移动端图标名')
         .option('--dry-run', '只打印请求体，不提交')
@@ -521,13 +622,16 @@ function registerOperationCommand(program) {
         .option('--token <token>', '鉴权 Token（覆盖配置）')
         .option('--json', '以 JSON 输出结果')
         .action(async (opts) => {
-        const { payload, kind } = buildCreatePayload(opts);
+        const client = createClient(opts);
+        const flow = opts.triggerFlow
+            ? await flow_1.flowApi.get(client, String(opts.triggerFlow))
+            : undefined;
+        const { payload, kind } = buildCreatePayload(opts, flow);
         if (opts.dryRun) {
             logger_1.logger.info(logger_1.color.gray(`# ${KIND_META[kind].label} · 表单 ${String(opts.formId)}（dry-run）`));
             logger_1.logger.json(payload);
             return;
         }
-        const client = createClient(opts);
         logger_1.logger.step(`新建业务操作：${String(opts.name)}（${KIND_META[kind].label}）`);
         const result = await operation_1.operationApi.add(client, payload);
         const fdId = typeof result === 'string' ? result : result?.fdId;
@@ -551,6 +655,8 @@ function registerOperationCommand(program) {
         .option('--url <url>', '打开链接地址（link）')
         .option('--script <code|@file>', '脚本内容或 @文件（script）')
         .option('--dialog-id <fdId>', '对话框 id（dialog）')
+        .option('--trigger-flow <fdId>', '切换为触发动作流（需 StartActiveNode + 已启用）')
+        .option('--inc-params <json|@file>', '动作流入参：[{field:{name},value:{val}}]')
         .option('--need-select', '点击前需勾选数据')
         .option('--no-need-select', '不需要勾选数据')
         .option('--enable', '启用该操作')
@@ -570,7 +676,10 @@ function registerOperationCommand(program) {
         const current = await operation_1.operationApi.get(client, fdId);
         if (!current?.fdId)
             throw new Error(`业务操作不存在：${fdId}`);
-        const { payload, kind } = buildUpdatePayload(current, opts);
+        const flow = opts.triggerFlow
+            ? await flow_1.flowApi.get(client, String(opts.triggerFlow))
+            : undefined;
+        const { payload, kind } = buildUpdatePayload(current, opts, flow);
         if (opts.dryRun) {
             logger_1.logger.info(logger_1.color.gray(`# ${KIND_META[kind].label} · ${current.fdName}（dry-run）`));
             logger_1.logger.json(payload);

package/dist/generator/flow/compiler.js

@@ -0,0 +1,397 @@
+"use strict";
+/**
+ * 动作流编译器：Flow Spec（声明式 JSON） → fdDesign（IDE 可回显的设计 JSON 字符串）
+ *
+ * 关键源码依据：
+ * - 节点结构 enter.tsx:367-393：{ id, code, name, type, nodeType, drawAttr:{bounds},
+ *   extraAttr:{context_*}, ...generateNodeData 字段 }
+ * - 连线结构 enter.tsx:395-407：{ id, name, type:'line', sourceRef, targetRef,
+ *   drawAttr:{style} }，不写 wayPoints
+ * - 保存/发布 enter.tsx:532-583：params = { ...dataSource, ...basicInfo,
+ *   fdDesign: JSON.stringify(...), fdStartWay }
+ * - 循环子画布 enter.tsx:357-365：subProcess = { nodes, lines, processVar, ... }
+ *
+ * 阶段 1 产出的是「结构 + 布局」合法的设计；extraAttr.context_* 由 spec.context
+ * 显式提供（或由后续阶段的 SchemaResolver 注入），不会凭空猜测。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasErrors = exports.NODE_SIZE = void 0;
+exports.normalizeGraph = normalizeGraph;
+exports.compileFlow = compileFlow;
+const layout_1 = require("./layout");
+Object.defineProperty(exports, "NODE_SIZE", { enumerable: true, get: function () { return layout_1.NODE_SIZE; } });
+const schema_1 = require("./schema");
+const validate_1 = require("./validate");
+Object.defineProperty(exports, "hasErrors", { enumerable: true, get: function () { return validate_1.hasErrors; } });
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function allocateId(ids, preferred) {
+    if (!ids.has(preferred))
+        return preferred;
+    for (let i = 2; i < 100; i++) {
+        const candidate = `${preferred}_${i}`;
+        if (!ids.has(candidate))
+            return candidate;
+    }
+    return `${preferred}_${Date.now().toString(36)}`;
+}
+/**
+ * 归一化图：自动补开始/结束节点、自动补首尾连线、分配 rank 与 lane。
+ *
+ * rank 语义：
+ * - ide 模式：BranchNode 的直接后继与分支节点同层（对应 IDE 的左右插入 R5）
+ * - layered 模式：所有边都推进一层
+ * lane 语义：lane 0 = 主链居中；分支目标取 ±1, ±2 … 左右对称。
+ */
+function normalizeGraph(spec, mode, hints = {}) {
+    const diagnostics = [];
+    const nodes = clone(spec.nodes);
+    const edges = [];
+    const seenEdge = new Set();
+    const addEdge = (edge) => {
+        const key = `${edge.from}->${edge.to}`;
+        if (seenEdge.has(key))
+            return;
+        seenEdge.add(key);
+        edges.push(edge);
+    };
+    for (const edge of clone(spec.edges))
+        addEdge(edge);
+    const ids = new Set(nodes.map((n) => n.id));
+    let start = nodes.find((n) => n.type === 'StartNode');
+    let end = nodes.find((n) => n.type === 'EndNode');
+    if (!start) {
+        const id = allocateId(ids, hints.startId ?? 'N1');
+        ids.add(id);
+        start = { id, type: 'StartNode', name: '开始' };
+        nodes.unshift(start);
+    }
+    if (!end) {
+        let maxN = 1;
+        for (const id of ids) {
+            const matched = /^N(\d+)$/.exec(id);
+            if (matched)
+                maxN = Math.max(maxN, Number(matched[1]));
+        }
+        const id = allocateId(ids, hints.endId ?? `N${maxN + 1}`);
+        ids.add(id);
+        end = { id, type: 'EndNode', name: '结束' };
+        nodes.push(end);
+    }
+    const startId = start.id;
+    const endId = end.id;
+    const degree = () => {
+        const incoming = new Map();
+        const outgoing = new Map();
+        for (const edge of edges) {
+            outgoing.set(edge.from, (outgoing.get(edge.from) ?? 0) + 1);
+            incoming.set(edge.to, (incoming.get(edge.to) ?? 0) + 1);
+        }
+        return { incoming, outgoing };
+    };
+    const business = nodes.filter((n) => n.id !== startId && n.id !== endId);
+    let deg = degree();
+    for (const node of business) {
+        if ((deg.incoming.get(node.id) ?? 0) === 0)
+            addEdge({ from: startId, to: node.id });
+    }
+    deg = degree();
+    for (const node of business) {
+        if ((deg.outgoing.get(node.id) ?? 0) === 0)
+            addEdge({ from: node.id, to: endId });
+    }
+    if (business.length === 0 && edges.length === 0)
+        addEdge({ from: startId, to: endId });
+    const byId = new Map(nodes.map((n) => [n.id, n]));
+    const ranks = { [startId]: 0 };
+    const branchTargets = new Set();
+    for (const edge of edges) {
+        if (byId.get(edge.from)?.type === 'BranchNode')
+            branchTargets.add(edge.to);
+    }
+    // 迭代松弛求最长路径层级；不收敛即存在环
+    const limit = nodes.length + 2;
+    let converged = false;
+    for (let pass = 0; pass < limit; pass++) {
+        let changed = false;
+        for (const edge of edges) {
+            const fromRank = ranks[edge.from];
+            if (fromRank === undefined)
+                continue;
+            const sameRank = mode === 'ide' && byId.get(edge.from)?.type === 'BranchNode';
+            const candidate = sameRank ? fromRank : fromRank + 1;
+            if (ranks[edge.to] === undefined || candidate > ranks[edge.to]) {
+                ranks[edge.to] = candidate;
+                changed = true;
+            }
+        }
+        if (!changed) {
+            converged = true;
+            break;
+        }
+    }
+    if (!converged) {
+        diagnostics.push({ level: 'error', code: 'GRAPH_CYCLE', message: '图中存在环，动作流必须是 DAG（IDE 禁止回环）' });
+    }
+    const maxRank = Math.max(0, ...Object.values(ranks));
+    for (const node of nodes) {
+        if (ranks[node.id] === undefined) {
+            diagnostics.push({
+                level: 'warn', code: 'GRAPH_ORPHAN',
+                message: `节点 ${node.id} 未连接到主流程，已放置在末层`, nodeId: node.id,
+            });
+            ranks[node.id] = maxRank + 1;
+        }
+    }
+    const normalized = nodes.map((node) => ({
+        ...node,
+        _rank: node.rank ?? ranks[node.id] ?? 0,
+        _lane: node.lane ?? 0,
+        _isStart: node.id === startId,
+        _isEnd: node.id === endId,
+        _isBranchTarget: branchTargets.has(node.id),
+    }));
+    // 层内泳道分配：主链/分支节点优先占 lane 0，分支目标左右对称
+    const byRank = new Map();
+    for (const node of normalized) {
+        const group = byRank.get(node._rank) ?? [];
+        group.push(node);
+        byRank.set(node._rank, group);
+    }
+    for (const group of byRank.values()) {
+        const priority = (n) => n._isBranchTarget ? 2 : n._isStart || n._isEnd || n.type === 'BranchNode' ? 0 : 1;
+        group.sort((a, b) => priority(a) - priority(b));
+        const used = new Set();
+        for (const node of group) {
+            if (node.lane !== undefined) {
+                used.add(node.lane);
+                continue;
+            }
+            const candidates = node._isBranchTarget
+                ? [-1, 1, -2, 2, -3, 3, -4, 4]
+                : [0, -1, 1, -2, 2, -3, 3, -4, 4];
+            let lane = candidates.find((value) => !used.has(value));
+            if (lane === undefined)
+                lane = used.size + 1;
+            used.add(lane);
+            node._lane = lane;
+        }
+    }
+    return { graph: { nodes: normalized, edges, startId, endId }, diagnostics };
+}
+/** 构造 startNodeDef（startNode.tsx:193-216 的 fdProcessActive） */
+function buildStartNodeDef(node, ctx) {
+    const provided = node.config?.startNodeDef;
+    if (provided && typeof provided === 'object' && !Array.isArray(provided)) {
+        return provided;
+    }
+    const trigger = ctx.trigger ?? {};
+    const way = ctx.startWay;
+    // 平台落库的 inParam 是 JSON 字符串（真实 get 回包中 fdProcessActive.fdInParam 与
+    // startNodeDef.inParam 均为字符串）；spec 里允许写成对象，这里统一序列化。
+    const inParam = trigger.inParam !== undefined && typeof trigger.inParam !== 'string'
+        ? JSON.stringify(trigger.inParam)
+        : trigger.inParam;
+    if (way === 'StartActiveNode') {
+        const runTypes = Array.isArray(trigger.fdRunType) ? trigger.fdRunType : [];
+        const fdFormRelation = trigger.fdFormRelation ?? '0';
+        return {
+            type: way,
+            operateTrigger: runTypes.includes('operate') || trigger.operateTrigger === true,
+            bpmTrigger: runTypes.includes('bpm') || trigger.bpmTrigger === true,
+            apiTrigger: runTypes.includes('api') || trigger.apiTrigger === true,
+            inParamType: trigger.inParamType,
+            inParam,
+            fdFormRelation,
+            formId: fdFormRelation === '0' ? undefined : trigger.formId,
+            dataType: trigger.dataType ?? 1,
+            entityId: trigger.entityId,
+        };
+    }
+    return { type: way, ...trigger, ...(inParam !== undefined ? { inParam } : {}) };
+}
+function buildNode(node, bounds, ctx, branchDefaults, branchFormulas, diagnostics) {
+    const config = { ...(schema_1.NODE_DEFAULTS[node.type] ?? {}), ...(node.config ?? {}) };
+    const picked = {};
+    const whitelist = schema_1.NODE_FIELD_WHITELIST[node.type];
+    if (whitelist) {
+        for (const field of whitelist) {
+            if (field in config && config[field] !== undefined)
+                picked[field] = config[field];
+        }
+    }
+    else {
+        Object.assign(picked, config);
+    }
+    if (node._isStart && ctx.isRoot)
+        picked.startNodeDef = buildStartNodeDef(node, ctx);
+    if (node.type === 'BranchNode') {
+        const defaultTarget = branchDefaults.get(node.id);
+        if (defaultTarget !== undefined)
+            picked.defaultTargetRef = defaultTarget;
+        // 平台 IDE 的 branchFormulas[].line 引用连线 id；由编译器按实际出边自动生成。
+        const auto = branchFormulas.get(node.id);
+        if (picked.formulaConfig === undefined && auto !== undefined)
+            picked.formulaConfig = auto;
+    }
+    if (node.type === 'FilterDataNode' && picked.formula && typeof picked.formula === 'object') {
+        picked.formula = JSON.stringify(picked.formula);
+    }
+    // 循环节点子画布：独立坐标系、独立 ID 前缀（graphId = <父链>-<循环节点 id>）
+    if (node.subProcess) {
+        const subResult = compileGraph(node.subProcess, {
+            ...ctx,
+            startId: `${node.id}_1`,
+            endId: `${node.id}_2`,
+            centerX: ctx.options.subCenterX ?? ctx.centerX,
+            isRoot: false,
+        });
+        diagnostics.push(...subResult.diagnostics);
+        picked.subProcess = {
+            nodes: subResult.design.nodes,
+            lines: subResult.design.lines,
+            ...(node.subProcess.processVar ? { processVar: node.subProcess.processVar } : {}),
+            ...(node.subProcess.processVarInitConfigs !== undefined
+                ? { processVarInitConfigs: node.subProcess.processVarInitConfigs }
+                : {}),
+        };
+    }
+    const context = (node.context ?? {});
+    const extraAttr = {};
+    for (const key of schema_1.CONTEXT_KEYS) {
+        if (context[key] !== undefined)
+            extraAttr[key] = context[key];
+    }
+    return {
+        id: node.id,
+        // 真实平台保存时主画布节点通常不带 code（IDE 回显时以 id 兜底）；
+        // 仅当 spec 显式声明 code 时才写出。
+        ...(node.code ? { code: node.code } : {}),
+        name: node.name ?? node.type,
+        type: 'node',
+        nodeType: node.type,
+        ...(node.dynamicProps ? { dynamicProps: node.dynamicProps } : {}),
+        drawAttr: { bounds: bounds[node.id] ?? { x: 0, y: 0, ...(0, layout_1.nodeSize)(node.type) } },
+        extraAttr,
+        ...picked,
+    };
+}
+function compileGraph(spec, ctx) {
+    const mode = ctx.options.mode ?? 'ide';
+    const normalized = normalizeGraph(spec, mode, { startId: ctx.startId, endId: ctx.endId });
+    const graphDiagnostics = (0, validate_1.validateGraph)(normalized.graph, spec, ctx.startWay);
+    const diagnostics = [
+        ...normalized.diagnostics,
+        ...(ctx.isRoot ? graphDiagnostics : graphDiagnostics.filter((d) => !d.code.startsWith('START_'))),
+    ];
+    const layout = (0, layout_1.layoutGraph)(normalized.graph, { ...ctx.options, mode, centerX: ctx.centerX ?? ctx.options.centerX });
+    diagnostics.push(...layout.diagnostics);
+    const branchDefaults = new Map();
+    for (const edge of normalized.graph.edges) {
+        if (edge.default)
+            branchDefaults.set(edge.from, edge.to);
+    }
+    // 连线 id 先确定，formulaConfig.branchFormulas[].line 需要引用它们。
+    const nodeById = new Map(normalized.graph.nodes.map((n) => [n.id, n]));
+    const lineIdOf = new Map(normalized.graph.edges.map((e, i) => [e, `L${i + 1}`]));
+    const branchFormulas = new Map();
+    for (const node of normalized.graph.nodes) {
+        if (node.type !== 'BranchNode')
+            continue;
+        const outgoing = normalized.graph.edges.filter((e) => e.from === node.id);
+        if (outgoing.length === 0)
+            continue;
+        // 默认分支排 priority 1，其余按出边顺序；与真实 condition.tsx 的 branchFormulas 一致。
+        const ordered = [...outgoing].sort((a, b) => Number(Boolean(b.default)) - Number(Boolean(a.default)));
+        branchFormulas.set(node.id, {
+            branchFormulas: ordered.map((edge, index) => ({
+                line: lineIdOf.get(edge),
+                targetRef: edge.to,
+                priority: index + 1,
+                // 默认分支不配公式（与平台 condition.tsx 的 branchFormulas 一致）
+                ...(edge.formula !== undefined && !edge.default
+                    ? { formula: typeof edge.formula === 'string' ? edge.formula : JSON.stringify(edge.formula) }
+                    : {}),
+            })),
+        });
+    }
+    const nodes = normalized.graph.nodes.map((node) => buildNode(node, layout.bounds, ctx, branchDefaults, branchFormulas, diagnostics));
+    const lines = normalized.graph.edges.map((edge) => {
+        // 条件分支出边需要左右锚点，否则 IDE 里两条线会重叠（真实 style: exitX=0/1）。
+        const source = nodeById.get(edge.from);
+        const target = nodeById.get(edge.to);
+        const isBranchOut = source?.type === 'BranchNode';
+        const exitX = isBranchOut && target ? (target._lane < 0 ? 0 : target._lane > 0 ? 1 : 0.5) : 0.5;
+        const style = isBranchOut
+            ? `line;exitX=${exitX};exitY=0.5;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;`
+            : '';
+        return {
+            id: lineIdOf.get(edge),
+            name: edge.name ?? '',
+            type: 'line',
+            ...(edge.dynamicProps ? { dynamicProps: edge.dynamicProps } : {}),
+            sourceRef: edge.from,
+            targetRef: edge.to,
+            // 平台保存时 item.style 为空 → JSON.stringify 后 drawAttr 为 {}；
+            // 仅 --emit-waypoints 时额外写入 wayPoints（非 IDE 原生行为）。
+            drawAttr: ctx.options.emitWayPoints
+                ? { style, wayPoints: [] }
+                : isBranchOut ? { style } : {},
+        };
+    });
+    const design = {
+        nodes,
+        lines,
+        ...(spec.processVar ? { processVar: spec.processVar } : {}),
+        ...(spec.processVarInitConfigs !== undefined ? { processVarInitConfigs: spec.processVarInitConfigs } : {}),
+    };
+    const bounds = normalized.graph.nodes
+        .map((node) => ({
+        id: node.id,
+        type: node.type,
+        bounds: layout.bounds[node.id],
+        rank: node._rank,
+        lane: node._lane,
+    }))
+        .filter((item) => item.bounds !== undefined);
+    return { design, bounds, rankCenters: layout.rankCenters, diagnostics, graph: normalized.graph };
+}
+/**
+ * 编译入口：返回可直接与 basicInfo 一起提交给 addDraft / addPublish 的 fdDesign。
+ * 注意：调用方应在 hasErrors(result.diagnostics) 为真时阻止发包（除非 --force）。
+ */
+function compileFlow(spec, options = {}) {
+    const startWay = spec.startWay ?? 'StartActiveNode';
+    const diagnostics = (0, validate_1.validateSpec)(spec);
+    const graphResult = compileGraph(spec, {
+        startWay,
+        trigger: spec.trigger,
+        options,
+        centerX: options.centerX ?? spec.centerX,
+        isRoot: true,
+    });
+    diagnostics.push(...graphResult.diagnostics);
+    const basicInfo = {
+        fdName: spec.name,
+        fdCode: spec.code,
+        fdStartWay: startWay,
+        fdStatus: -1,
+        fdTransactionType: spec.fdTransactionType ?? 'multiTransaction',
+        fdLogDetail: spec.fdLogDetail ?? false,
+        ...(spec.appCode ? { fdAppCode: spec.appCode } : {}),
+        ...(spec.fdDesc !== undefined ? { fdDesc: spec.fdDesc } : {}),
+        ...(spec.fdCategory ? { fdCategory: spec.fdCategory } : {}),
+        ...(spec.fdIcon ? { fdIcon: spec.fdIcon } : {}),
+        ...(spec.fdId ? { fdId: spec.fdId } : {}),
+        ...(spec.basicInfo ?? {}),
+    };
+    return {
+        fdDesign: JSON.stringify(graphResult.design),
+        design: graphResult.design,
+        fdStartWay: startWay,
+        basicInfo,
+        bounds: graphResult.bounds,
+        diagnostics,
+    };
+}

package/dist/generator/flow/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./layout"), exports);
+__exportStar(require("./validate"), exports);
+__exportStar(require("./schema-resolver"), exports);
+__exportStar(require("./compiler"), exports);