feat(runTransform): yield similar events to AstxWorkerPool.runTransform

BREAKING CHANGE: the yield type of `runTransform` is now
 `{ type: 'result', result: TransformResult } | Progress` instead of `TransformResult`.

Author: jedwards1211

src/cli/transform.ts

@@ -8,15 +8,19 @@ import fs from 'fs-extra'
 import dedent from 'dedent-js'
 import CodeFrameError from '../util/CodeFrameError'
 import { formatIpcMatches } from '../util/formatMatches'
-import { AstxWorkerPool, astxCosmiconfig, runTransform } from '../node'
+import {
+  AstxWorkerPool,
+  astxCosmiconfig,
+  runTransform,
+  Progress,
+} from '../node'
 import {
   invertIpcError,
   IpcTransformResult,
   makeIpcTransformResult,
 } from '../node/ipc'
 import { Transform } from '../Astx'
 import ansiEscapes from 'ansi-escapes'
-import { Progress } from '../node/AstxWorkerPool'
 import { spinner } from './spinner'
 import '../node/registerTsNode'
 import isInteractive from '../util/isInteractive'
@@ -183,9 +187,9 @@ const transform: CommandModule<Options> = {
         ? pool.runTransform(runTransformOptions)
         : runTransform(runTransformOptions)) {
         const event: { type: 'result'; result: IpcTransformResult } | Progress =
-          pool
-            ? (_event as any)
-            : { type: 'result', result: makeIpcTransformResult(_event as any) }
+          !pool && _event.type === 'result'
+            ? { type: 'result', result: makeIpcTransformResult(_event as any) }
+            : (_event as any)
         if (event.type === 'progress') {
           progress = event
           if (interactive) showProgress()

src/node/AstxWorkerPool.ts

@@ -6,18 +6,12 @@ import astxGlob from './astxGlob'
 import AstxWorker from './AstxWorker'
 import AsyncPool from './AsyncPool'
 import { astxCosmiconfig } from './astxCosmiconfig'
-import { RunTransformOptions } from './runTransform'
+import { RunTransformOptions, Progress } from './runTransform'
 import { RunTransformOnFileOptions } from './runTransformOnFile'
 import PushPullIterable from '../util/PushPullIterable'
 
 class AbortedError extends Error {}
 
-export type Progress = {
-  type: 'progress'
-  completed: number
-  total: number
-  globDone: boolean
-}
 export default class AstxWorkerPool {
   pool: AsyncPool<AstxWorker>
 

src/node/index.ts

@@ -2,6 +2,7 @@ export { default as AstxWorkerPool } from './AstxWorkerPool'
 export {
   default as runTransform,
   type RunTransformOptions,
+  type Progress,
 } from './runTransform'
 export {
   default as runTransformOnFile,

src/node/runTransform.ts

@@ -6,6 +6,13 @@ import { astxCosmiconfig } from './astxCosmiconfig'
 import { Transform, TransformResult } from '../Astx'
 import Gitignore from 'gitignore-fs'
 
+export type Progress = {
+  type: 'progress'
+  completed: number
+  total: number
+  globDone: boolean
+}
+
 export type RunTransformOptions = {
   gitignore?: Gitignore | null
   transform?: Transform
@@ -26,17 +33,36 @@ export default async function* runTransform({
   cwd = process.cwd(),
   config,
   signal,
-}: RunTransformOptions): AsyncIterable<TransformResult> {
+}: RunTransformOptions): AsyncIterable<
+  { type: 'result'; result: TransformResult } | Progress
+> {
   clearCache()
   astxCosmiconfig.clearSearchCache()
 
   const transform = transformFile ? await import(transformFile) : _transform
   if (signal?.aborted) return
   if (!transform) throw new Error(`transform or transformFile is required`)
 
+  let completed = 0,
+    total = 0,
+    globDone = false
+
+  const progress = (): Progress => ({
+    type: 'progress',
+    completed,
+    total,
+    globDone,
+  })
+
+  yield progress()
+  if (signal?.aborted) return
+
   const paths = _paths?.length ? _paths : [cwd]
   for (const include of paths) {
     for await (const file of astxGlob({ include, exclude, cwd, gitignore })) {
+      if (signal?.aborted) return
+      total++
+      yield progress()
       if (signal?.aborted) return
       let transformed
       try {
@@ -46,14 +72,21 @@ export default async function* runTransform({
           config,
           signal,
         })
+        completed++
+        yield progress()
       } catch (error: any) {
         if (error.message === 'aborted' && signal?.aborted) return
         throw error
       }
       if (signal?.aborted) return
-      yield transformed
+      yield { type: 'result', result: transformed }
     }
   }
   if (signal?.aborted) return
+
+  globDone = true
+  yield progress()
+  if (signal?.aborted) return
+
   await transform.finish?.()
 }