Function processAsync

yaml-flow-editor/src/App.tsx:1289–1405

()

          
          // Process files asynchronously to avoid blocking UI
          const processAsync = () => {
            try {
              // Parse all files to find main candidate
              const parsedList: Array<{ path: string; content: string; parsed: { name?: string; workflow?: unknown[] } | null }> = [];
              
              const parseBatch = (startIndex: number) => {
                try {
                  const endIndex = Math.min(startIndex + BATCH_SIZE, contents.length);
                  const batch = contents.slice(startIndex, endIndex);
                  
                  // Parse this batch
                  batch.forEach((c) => {
                    try {
                      parsedList.push({
                        path: c.path,
                        content: c.content,
                        parsed: yamlLib.load(c.content) as { name?: string; workflow?: unknown[] } | null,
                      });
                    } catch (e) {
                      console.warn(`Failed to parse ${c.path}:`, e);
                      parsedList.push({
                        path: c.path,
                        content: c.content,
                        parsed: null,
                      });
                    }
                  });
                  
                  // Continue with next batch or finish
                  if (endIndex < contents.length) {
                    if (typeof requestIdleCallback !== 'undefined') {
                      requestIdleCallback(() => parseBatch(endIndex), { timeout: 100 });
                    } else {
                      setTimeout(() => parseBatch(endIndex), 0);
                    }
                  } else {
                    // All parsed, now find main candidate and process
                    findMainAndProcess();
                  }
                } catch (e) {
                  console.error('Error in parseBatch:', e);
                  // Still try to process what we have
                  if (parsedList.length > 0) {
                    findMainAndProcess();
                  }
                }
              };
              
              const findMainAndProcess = () => {
                try {
                  const withWorkflow = parsedList.filter(
                    (p) => p.parsed && typeof p.parsed === 'object' && Array.isArray(p.parsed.workflow) && p.parsed.workflow.length > 0
                  );
                  const notInModules = withWorkflow.filter(
                    (p) => !/[/\\]modules?[/\\]/i.test(p.path) && !p.path.startsWith('modules/')
                  );
                  const mainCandidate = notInModules.find((p) => looksLikeMainPlan(p.parsed!))
                    ?? notInModules[0]