Function collectDependentModules

yaml-flow-editor/src/utils/collectModules.ts:9–182

(
  mainYaml: string,
  modulesByPath: Record<string, { content: string }>,
  nodes: FlowNode[],
)

 * Returns a Map of modulePath → yamlContent for every transitively-referenced module.
 */
export function collectDependentModules(
  mainYaml: string,
  modulesByPath: Record<string, { content: string }>,
  nodes: FlowNode[],
): Map<string, string> {
  const result = new Map<string, string>();
  const visited = new Set<string>();

  // Collect per-node moduleContents overrides (call/parallel/gather nodes)
  const nodeOverrides: Record<string, string> = {};
  for (const node of nodes) {
    const data = node.data as Record<string, unknown>;
    const mc = data.moduleContents as Record<string, string> | undefined;
    if (mc) {
      for (const [path, content] of Object.entries(mc)) {
        nodeOverrides[path] = content;
      }
    }
  }

  // Resolve module content by path: node overrides > global modulesByPath (with normalization)
  function resolveContent(modulePath: string): string | undefined {
    if (nodeOverrides[modulePath]) return nodeOverrides[modulePath];

    // Direct lookup
    if (modulesByPath[modulePath]) return modulesByPath[modulePath].content;

    // Normalize: strip leading ./
    const stripped = modulePath.replace(/^\.\//, '');
    if (modulesByPath[stripped]) return modulesByPath[stripped].content;

    // Strip workflows/ prefix
    const noPrefix = stripped.replace(/^workflows\//, '');
    if (modulesByPath[noPrefix]) return modulesByPath[noPrefix].content;

    // Suffix match: find any key ending with the path
    const keys = Object.keys(modulesByPath);
    const suffixMatch = keys.find(
      (k) => k.endsWith('/' + stripped) || k.endsWith('/' + noPrefix),
    );
    if (suffixMatch) return modulesByPath[suffixMatch].content;

    return undefined;
  }

  // Extract module paths from a list of workflow steps
  function extractModulePaths(steps: WorkflowStep[]): string[] {
    const paths: string[] = [];
    for (const step of steps) {
      if ('call' in step && step.call) {
        const c = step.call as { module?: string };
        if (c.module) paths.push(c.module);
      }
      if ('parallel' in step && step.parallel) {
        const p = step.parallel as { module?: string };
        if (p.module) paths.push(p.module);
      }
      if ('gather' in step && step.gather) {