feat: support async transformation

benches/un-undefined.ts

@@ -18,8 +18,8 @@ const main = async () => {
         title,
         ...([10, 100, 1000, 5000].map((count) => {
             const source = snippet.repeat(count)
-            return add(`items=${count}`, () => {
-                runTransformationRules({ path: '', source }, [title])
+            return add(`items=${count}`, async () => {
+                await runTransformationRules({ path: '', source }, [title])
             })
         })),
         cycle(),

packages/cli/src/unminify.worker.ts

@@ -13,7 +13,7 @@ export async function unminify(data?: UnminifyWorkerParams) {
         const source = await fsa.readFile(inputPath, 'utf-8')
         const fileInfo = { path: inputPath, source }
 
-        const { code, timing } = runDefaultTransformationRules(fileInfo, { moduleMeta, moduleMapping })
+        const { code, timing } = await runDefaultTransformationRules(fileInfo, { moduleMeta, moduleMapping })
         await fsa.ensureFile(outputPath)
         await fsa.writeFile(outputPath, code, 'utf-8')
 

packages/playground/src/unminify.worker.ts

@@ -1,14 +1,14 @@
 import { runTransformationRules } from '@wakaru/unminify'
 import type { CodeModParams, TransformedModule } from './types'
 
-onmessage = (
+onmessage = async (
     msg: MessageEvent<CodeModParams>,
 ) => {
     try {
         const { name, module, transformationRuleIds, moduleMeta, moduleMapping } = msg.data
         const fileInfo = { path: name, source: module.code }
         const params = { moduleMeta, moduleMapping }
-        const { code } = runTransformationRules(fileInfo, transformationRuleIds, params)
+        const { code } = await runTransformationRules(fileInfo, transformationRuleIds, params)
         const transformedDep: TransformedModule = { ...module, transformed: code }
         postMessage(transformedDep)
     }

packages/shared/src/jscodeshiftRule.ts

@@ -1,6 +1,6 @@
 import { jscodeshiftWithParser as j, printSourceWithErrorLoc, toSource } from './jscodeshift'
-import type { BaseTransformationRule, SharedParams } from './rule'
-import type { Collection, JSCodeshift, Transform } from 'jscodeshift'
+import type { BaseTransformationRule, JSCodeshiftTransform, SharedParams } from './rule'
+import type { Collection, JSCodeshift } from 'jscodeshift'
 import type { ZodSchema, z } from 'zod'
 
 export interface Context {
@@ -61,8 +61,8 @@ export class JSCodeshiftTransformationRule<Schema extends ZodSchema = ZodSchema>
     /**
      * Generate a jscodeshift compatible transform
      */
-    toJSCodeshiftTransform(): Transform {
-        const transform: Transform = (file, api, options) => {
+    toJSCodeshiftTransform(): JSCodeshiftTransform {
+        const transform: JSCodeshiftTransform = (file, api, options) => {
             const root = api.jscodeshift(file.source)
 
             this.execute({

packages/shared/src/rule.ts

@@ -1,7 +1,7 @@
 import type { JSCodeshiftTransformationRule } from './jscodeshiftRule'
 import type { StringTransformationRule } from './stringRule'
 import type { ModuleMapping, ModuleMeta } from './types'
-import type { Transform } from 'jscodeshift'
+import type { API, FileInfo, Options } from 'jscodeshift'
 import type { ZodSchema } from 'zod'
 
 export * from './jscodeshiftRule'
@@ -12,6 +12,21 @@ export interface SharedParams {
     moduleMeta?: ModuleMeta
 }
 
+/**
+ * `Transform` from `jscodeshift`. The type in `jscodeshift` is not accurate,
+ * so we have to re-define it here.
+ *
+ * Async support has been added in https://github.com/facebook/jscodeshift/pull/237
+ */
+export interface JSCodeshiftTransform {
+    /**
+     * If a string is returned and it is different from passed source, the transform is considered to be successful.
+     * If a string is returned but it's the same as the source, the transform is considered to be unsuccessful.
+     * If nothing is returned, the file is not supposed to be transformed (which is ok).
+     */
+    (file: FileInfo, api: API, options: Options): Promise<string | null | undefined | void> | string | null | undefined | void
+}
+
 export interface BaseTransformationRule {
     type: 'jscodeshift' | 'string' | 'rule-set'
     /**
@@ -34,7 +49,7 @@ export interface BaseTransformationRule {
     /**
      * convert to jscodeshift compatible transform
      */
-    toJSCodeshiftTransform(): Transform
+    toJSCodeshiftTransform(): JSCodeshiftTransform
 }
 
 export type TransformationRule<Schema extends ZodSchema = ZodSchema> =
@@ -71,13 +86,13 @@ export class MergedTransformationRule implements BaseTransformationRule {
         this.rules = rules
     }
 
-    toJSCodeshiftTransform(): Transform {
+    toJSCodeshiftTransform(): JSCodeshiftTransform {
         const rules = this.rules
-        return function mergedTransform(file, api, options) {
+        return async function mergedTransform(file, api, options) {
             let source = file.source
             for (const rule of rules) {
                 const transform = rule.toJSCodeshiftTransform()
-                const newResult = transform({ ...file, source }, api, options)
+                const newResult = await transform({ ...file, source }, api, options)
                 if (newResult) source = newResult
             }
             return source

packages/shared/src/stringRule.ts

@@ -1,8 +1,10 @@
-import type { BaseTransformationRule } from './rule'
-import type { Transform } from 'jscodeshift'
+import type { BaseTransformationRule, JSCodeshiftTransform } from './rule'
 import type { ZodSchema, z } from 'zod'
 
-export type StringTransformation<Schema extends ZodSchema = ZodSchema> = (code: string, params: z.infer<Schema>) => string | void
+export type StringTransformation<Schema extends ZodSchema = ZodSchema> = (
+    code: string,
+    params: z.infer<Schema>
+) => Promise<string | void> | string | void
 
 export class StringTransformationRule<Schema extends ZodSchema = ZodSchema> implements BaseTransformationRule {
     type = 'string' as const
@@ -33,27 +35,27 @@ export class StringTransformationRule<Schema extends ZodSchema = ZodSchema> impl
         this.schema = schema
     }
 
-    execute({
+    async execute({
         source, filename, params,
     }: {
         source: string
         filename: string
         params: z.infer<Schema>
     }) {
         try {
-            return this.transform(source, params)
+            return await this.transform(source, params)
         }
         catch (err: any) {
             console.error(`\nError running rule ${this.name} on ${filename}`, err)
         }
     }
 
-    toJSCodeshiftTransform(): Transform {
-        const transform: Transform = (file, _api, options) => {
+    toJSCodeshiftTransform(): JSCodeshiftTransform {
+        const transform: JSCodeshiftTransform = async (file, _api, options) => {
             const { source } = file
             const params = options as z.infer<Schema>
             try {
-                const newSource = this.transform(source, params)
+                const newSource = await this.transform(source, params)
                 return newSource ?? source
             }
             catch (err) {

packages/unminify/src/index.ts

@@ -26,7 +26,7 @@ export function runTransformationRules<P extends Record<string, any>>(
     return executeTransformationRules(fileInfo.source, fileInfo.path, rules, params)
 }
 
-function executeTransformationRules<P extends Record<string, any>>(
+async function executeTransformationRules<P extends Record<string, any>>(
     /** The source code */
     source: string,
     /** The file path */
@@ -84,7 +84,7 @@ function executeTransformationRules<P extends Record<string, any>>(
 
                 try {
                     const stopMeasure2 = timing.startMeasure(filePath, rule.id)
-                    currentSource = rule.execute({
+                    currentSource = await rule.execute({
                         source: currentSource,
                         filename: filePath,
                         params,