with-zephyr 0.1.0-next.1 → 0.1.1-next.2

package/README.md

@@ -34,13 +34,14 @@ bunx with-zephyr
 
 ## Supported Bundlers
 
-This codemod supports **11+ bundlers** with their respective Zephyr plugins:
+This codemod supports **12+ bundlers** with their respective Zephyr plugins:
 
 - **Webpack** ([`zephyr-webpack-plugin`](https://www.npmjs.com/package/zephyr-webpack-plugin))
 - **Rspack** ([`zephyr-rspack-plugin`](https://www.npmjs.com/package/zephyr-rspack-plugin))
 - **Vite** ([`vite-plugin-zephyr`](https://www.npmjs.com/package/vite-plugin-zephyr))
 - **Rollup** ([`rollup-plugin-zephyr`](https://www.npmjs.com/package/rollup-plugin-zephyr))
 - **Rolldown** ([`zephyr-rolldown-plugin`](https://www.npmjs.com/package/zephyr-rolldown-plugin))
+- **Astro** ([`zephyr-astro-integration`](https://www.npmjs.com/package/zephyr-astro-integration))
 - **Modern.js** ([`zephyr-modernjs-plugin`](https://www.npmjs.com/package/zephyr-modernjs-plugin))
 - **RSPress** ([`zephyr-rspress-plugin`](https://www.npmjs.com/package/zephyr-rspress-plugin))
 - **Parcel** ([`parcel-reporter-zephyr`](https://www.npmjs.com/package/parcel-reporter-zephyr))
@@ -241,6 +242,7 @@ The codemod automatically detects and processes these configuration files:
 - `vite.config.js/ts/mjs`
 - `rollup.config.js/ts/mjs`
 - `rolldown.config.js/ts/mjs`
+- `astro.config.js/ts/mjs/mts`
 - `modern.config.js/ts/mjs`
 - `rspress.config.js/ts/mjs`
 - `rsbuild.config.js/ts/mjs`

package/dist/index.js

@@ -47910,280 +47910,302 @@ const esm_glob = Object.assign(glob_, {
     unescape: unescape_unescape
 });
 esm_glob.glob = esm_glob;
-const BUNDLER_CONFIGS = {
-    webpack: {
-        files: [
-            'webpack.config.js',
-            'webpack.config.ts',
-            'webpack.config.mjs'
-        ],
-        plugin: 'zephyr-webpack-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'compose-plugins',
-                matcher: /composePlugins\s*\(/,
-                transform: 'addToComposePlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            },
-            {
-                type: 'module-exports',
-                matcher: /module\.exports\s*=/,
-                transform: 'wrapModuleExports'
-            }
-        ]
-    },
-    rspack: {
-        files: [
-            'rspack.config.js',
-            'rspack.config.ts',
-            'rspack.config.mjs'
-        ],
-        plugin: 'zephyr-rspack-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'export-wrapped-call',
-                matcher: /export\s+default\s+withZephyr\s*\(\s*\)\s*\(/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'compose-plugins',
-                matcher: /composePlugins\s*\(/,
-                transform: 'addToComposePlugins'
-            },
-            {
-                type: 'export-default-object',
-                matcher: /export\s+default\s+\{/,
-                transform: 'wrapExportDefault'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            },
-            {
-                type: 'module-exports',
-                matcher: /module\.exports\s*=/,
-                transform: 'wrapModuleExports'
-            }
-        ]
-    },
-    vite: {
-        files: [
-            'vite.config.js',
-            'vite.config.ts',
-            'vite.config.mjs',
-            'vite.config.mts'
-        ],
-        plugin: 'vite-plugin-zephyr',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config-function',
-                matcher: /defineConfig\s*\(\s*\(\s*\)\s*=>\s*\(\s*\{/,
-                transform: 'addToVitePluginsInFunction'
-            },
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToVitePlugins'
-            },
-            {
-                type: 'export-default',
-                matcher: /export\s+default\s+\{/,
-                transform: 'addToVitePlugins'
-            }
-        ]
-    },
-    rollup: {
-        files: [
-            'rollup.config.js',
-            'rollup.config.ts',
-            'rollup.config.mjs'
-        ],
-        plugin: 'rollup-plugin-zephyr',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'export-array',
-                matcher: /export\s+default\s+\[/,
-                transform: 'addToRollupArrayConfig'
-            },
-            {
-                type: 'module-exports-function',
-                matcher: /module\.exports\s*=\s*\(\s*config\s*\)\s*=>/,
-                transform: 'addToRollupFunction'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    rolldown: {
-        files: [
-            'rolldown.config.js',
-            'rolldown.config.ts',
-            'rolldown.config.mjs'
-        ],
-        plugin: 'zephyr-rolldown-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToRolldownPlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    modernjs: {
-        files: [
-            'modern.config.js',
-            'modern.config.ts',
-            'modern.config.mjs'
-        ],
-        plugin: 'zephyr-modernjs-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToModernJSPlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    rspress: {
-        files: [
-            'rspress.config.js',
-            'rspress.config.ts',
-            'rspress.config.mjs'
-        ],
-        plugin: 'zephyr-rspress-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addToRSPressPlugins'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addToPluginsArray'
-            }
-        ]
-    },
-    parcel: {
-        files: [
-            '.parcelrc',
-            '.parcelrc.json'
-        ],
-        plugin: 'parcel-reporter-zephyr',
-        importName: null,
-        patterns: [
-            {
-                type: 'parcel-reporters',
-                matcher: /"reporters"\s*:\s*\[/,
-                transform: 'addToParcelReporters'
-            }
-        ]
-    },
-    repack: {
-        files: [
-            'rspack.config.js',
-            'rspack.config.ts',
-            'rspack.config.mjs'
-        ],
-        plugin: 'zephyr-repack-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'export-conditional-withzephyr',
-                matcher: /export\s+default\s+.*\?\s*withZephyr\s*\(\s*\)\s*\(/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'export-function-variable',
-                matcher: /export\s+default\s+(\w+)\s*;?\s*$/,
-                transform: 'wrapExportedFunction'
-            },
-            {
-                type: 'const-function-export',
-                matcher: /const\s+\w+\s*=\s*\w+\s*=>/,
-                transform: 'wrapExportedFunction'
-            }
-        ]
-    },
-    rsbuild: {
-        files: [
-            'rsbuild.config.js',
-            'rsbuild.config.ts',
-            'rsbuild.config.mjs'
-        ],
-        plugin: 'zephyr-rsbuild-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'zephyr-rsbuild-plugin-exists',
-                matcher: /zephyrRSbuildPlugin/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addZephyrRSbuildPlugin'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addZephyrRSbuildPlugin'
-            }
-        ]
-    },
-    rslib: {
-        files: [
-            'rslib.config.js',
-            'rslib.config.ts',
-            'rslib.config.mjs'
-        ],
-        plugin: 'zephyr-rsbuild-plugin',
-        importName: 'withZephyr',
-        patterns: [
-            {
-                type: 'zephyr-rsbuild-plugin-exists',
-                matcher: /zephyrRSbuildPlugin/,
-                transform: 'skipAlreadyWrapped'
-            },
-            {
-                type: 'define-config',
-                matcher: /defineConfig\s*\(\s*\{/,
-                transform: 'addZephyrRSbuildPlugin'
-            },
-            {
-                type: 'plugins-array',
-                matcher: /plugins\s*:\s*\[/,
-                transform: 'addZephyrRSbuildPlugin'
-            }
-        ]
-    }
+const astro_astroConfig = {
+    files: [
+        'astro.config.js',
+        'astro.config.ts',
+        'astro.config.mjs',
+        'astro.config.mts'
+    ],
+    plugin: 'zephyr-astro-integration',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config-function',
+            matcher: /defineConfig\s*\(\s*\(\s*\)\s*=>\s*\(\s*\{/,
+            transform: 'addToAstroIntegrationsInFunctionOrCreate'
+        },
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToAstroIntegrationsOrCreate'
+        },
+        {
+            type: 'export-default',
+            matcher: /export\s+default\s+\{/,
+            transform: 'addToAstroIntegrationsOrCreate'
+        }
+    ]
+};
+const modernjs_modernjsConfig = {
+    files: [
+        'modern.config.js',
+        'modern.config.ts',
+        'modern.config.mjs'
+    ],
+    plugin: 'zephyr-modernjs-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArrayOrCreate'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const parcel_parcelConfig = {
+    files: [
+        '.parcelrc',
+        '.parcelrc.json'
+    ],
+    plugin: 'parcel-reporter-zephyr',
+    importName: null,
+    patterns: [
+        {
+            type: 'parcel-reporters',
+            matcher: /"reporters"\s*:\s*\[/,
+            transform: 'addToParcelReporters'
+        }
+    ]
+};
+const repack_repackConfig = {
+    files: [
+        'rspack.config.js',
+        'rspack.config.ts',
+        'rspack.config.mjs'
+    ],
+    plugin: 'zephyr-repack-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'export-conditional-withzephyr',
+            matcher: /export\s+default\s+.*\?\s*withZephyr\s*\(\s*\)\s*\(/,
+            transform: 'skipAlreadyWrapped'
+        },
+        {
+            type: 'export-function-variable',
+            matcher: /export\s+default\s+(\w+)\s*;?\s*$/,
+            transform: 'wrapExportedFunction'
+        },
+        {
+            type: 'const-function-export',
+            matcher: /const\s+\w+\s*=\s*\w+\s*=>/,
+            transform: 'wrapExportedFunction'
+        }
+    ]
+};
+const rolldown_rolldownConfig = {
+    files: [
+        'rolldown.config.js',
+        'rolldown.config.ts',
+        'rolldown.config.mjs'
+    ],
+    plugin: 'zephyr-rolldown-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArrayOrCreate'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rollup_rollupConfig = {
+    files: [
+        'rollup.config.js',
+        'rollup.config.ts',
+        'rollup.config.mjs'
+    ],
+    plugin: 'rollup-plugin-zephyr',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'export-array',
+            matcher: /export\s+default\s+\[/,
+            transform: 'addToRollupArrayConfig'
+        },
+        {
+            type: 'module-exports-function',
+            matcher: /module\.exports\s*=\s*\(\s*config\s*\)\s*=>/,
+            transform: 'addToRollupFunction'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rsbuild_rsbuildConfig = {
+    files: [
+        'rsbuild.config.js',
+        'rsbuild.config.ts',
+        'rsbuild.config.mjs'
+    ],
+    plugin: 'zephyr-rsbuild-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rslib_rslibConfig = {
+    files: [
+        'rslib.config.js',
+        'rslib.config.ts',
+        'rslib.config.mjs'
+    ],
+    plugin: 'zephyr-rsbuild-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const rspack_rspackConfig = {
+    files: [
+        'rspack.config.js',
+        'rspack.config.ts',
+        'rspack.config.mjs'
+    ],
+    plugin: 'zephyr-rspack-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'export-wrapped-call',
+            matcher: /export\s+default\s+withZephyr\s*\(\s*\)\s*\(/,
+            transform: 'skipAlreadyWrapped'
+        },
+        {
+            type: 'compose-plugins',
+            matcher: /composePlugins\s*\(/,
+            transform: 'addToComposePlugins'
+        },
+        {
+            type: 'export-default-object',
+            matcher: /export\s+default\s+\{/,
+            transform: 'wrapExportDefault'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'module-exports',
+            matcher: /module\.exports\s*=/,
+            transform: 'wrapModuleExports'
+        }
+    ]
+};
+const rspress_rspressConfig = {
+    files: [
+        'rspress.config.js',
+        'rspress.config.ts',
+        'rspress.config.mjs'
+    ],
+    plugin: 'zephyr-rspress-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToPluginsArrayOrCreate'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        }
+    ]
+};
+const vite_viteConfig = {
+    files: [
+        'vite.config.js',
+        'vite.config.ts',
+        'vite.config.mjs',
+        'vite.config.mts'
+    ],
+    plugin: 'vite-plugin-zephyr',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'define-config-function',
+            matcher: /defineConfig\s*\(\s*\(\s*\)\s*=>\s*\(\s*\{/,
+            transform: 'addToVitePluginsInFunction'
+        },
+        {
+            type: 'define-config',
+            matcher: /defineConfig\s*\(\s*\{/,
+            transform: 'addToVitePlugins'
+        },
+        {
+            type: 'export-default',
+            matcher: /export\s+default\s+\{/,
+            transform: 'addToVitePlugins'
+        }
+    ]
+};
+const webpack_webpackConfig = {
+    files: [
+        'webpack.config.js',
+        'webpack.config.ts',
+        'webpack.config.mjs'
+    ],
+    plugin: 'zephyr-webpack-plugin',
+    importName: 'withZephyr',
+    patterns: [
+        {
+            type: 'compose-plugins',
+            matcher: /composePlugins\s*\(/,
+            transform: 'addToComposePlugins'
+        },
+        {
+            type: 'plugins-array',
+            matcher: /plugins\s*:\s*\[/,
+            transform: 'addToPluginsArray'
+        },
+        {
+            type: 'module-exports',
+            matcher: /module\.exports\s*=/,
+            transform: 'wrapModuleExports'
+        }
+    ]
 };
 function detectPackageManager(directory = process.cwd()) {
+    if (process.env.npm_config_user_agent) {
+        const userAgent = process.env.npm_config_user_agent.toLowerCase();
+        if (userAgent.includes('pnpm')) return 'pnpm';
+        if (userAgent.includes('yarn')) return 'yarn';
+        if (userAgent.includes('bun')) return 'bun';
+        if (userAgent.includes('npm')) return 'npm';
+    }
     const lockFiles = {
         'pnpm-lock.yaml': 'pnpm',
         'yarn.lock': 'yarn',
@@ -48216,12 +48238,6 @@ function detectPackageManager(directory = process.cwd()) {
             if (fs_0.existsSync(path_0.join(rootDir, 'lerna.json')) || fs_0.existsSync(path_0.join(rootDir, 'yarn.lock')) && rootDir === directory) return 'yarn';
         }
     } catch  {}
-    if (process.env.npm_config_user_agent) {
-        const userAgent = process.env.npm_config_user_agent.toLowerCase();
-        if (userAgent.includes('pnpm')) return 'pnpm';
-        if (userAgent.includes('yarn')) return 'yarn';
-        if (userAgent.includes('bun')) return 'bun';
-    }
     return 'npm';
 }
 function isPackageInstalled(packageName, directory = process.cwd()) {
@@ -48257,8 +48273,8 @@ function installPackage(directory, packageName, packageManager, isDev = true) {
     }
 }
 var lib = __webpack_require__("../../node_modules/.pnpm/@babel+parser@7.28.4/node_modules/@babel/parser/lib/index.js");
-var traverse_lib = __webpack_require__("../../node_modules/.pnpm/@babel+traverse@7.28.4_supports-color@5.5.0/node_modules/@babel/traverse/lib/index.js");
 var generator_lib = __webpack_require__("../../node_modules/.pnpm/@babel+generator@7.28.3/node_modules/@babel/generator/lib/index.js");
+var traverse_lib = __webpack_require__("../../node_modules/.pnpm/@babel+traverse@7.28.4_supports-color@5.5.0/node_modules/@babel/traverse/lib/index.js");
 var types_lib = __webpack_require__("../../node_modules/.pnpm/@babel+types@7.28.4/node_modules/@babel/types/lib/index.js");
 function parseFile(filePath) {
     const content = fs_0.readFileSync(filePath, 'utf8');
@@ -48300,6 +48316,18 @@ function writeFile(filePath, ast) {
     });
     fs_0.writeFileSync(filePath, output.code);
 }
+function hasZephyrPlugin(ast) {
+    let hasPlugin = false;
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'withZephyr'
+            })) hasPlugin = true;
+        }
+    });
+    return hasPlugin;
+}
+function skipAlreadyWrapped(_ast) {}
 function addZephyrImport(ast, pluginName, importName) {
     if (!importName) return;
     let hasImport = false;
@@ -48348,19 +48376,44 @@ function addZephyrRequire(ast, pluginName, importName) {
         });
     }
 }
-function transformers_hasZephyrPlugin(ast) {
-    let hasPlugin = false;
+function addToPluginsArray(ast) {
+    (0, traverse_lib["default"])(ast, {
+        ObjectProperty (path) {
+            if (types_lib.isIdentifier(path.node.key, {
+                name: 'plugins'
+            }) && types_lib.isArrayExpression(path.node.value)) path.node.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+        }
+    });
+}
+function addToPluginsArrayOrCreate(ast) {
+    let pluginAdded = false;
     (0, traverse_lib["default"])(ast, {
         CallExpression (path) {
             if (types_lib.isIdentifier(path.node.callee, {
-                name: 'withZephyr'
-            })) hasPlugin = true;
-        },
-        Identifier (path) {
-            if ('withZephyr' === path.node.name && types_lib.isCallExpression(path.parent) && path.parent.callee === path.node) hasPlugin = true;
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isObjectExpression(path.node.arguments[0])) {
+                const configObject = path.node.arguments[0];
+                let pluginsProperty = null;
+                for (const prop of configObject.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                    name: 'plugins'
+                }) && types_lib.isArrayExpression(prop.value)) {
+                    pluginsProperty = prop;
+                    break;
+                }
+                if (pluginsProperty && types_lib.isArrayExpression(pluginsProperty.value)) {
+                    pluginsProperty.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                    pluginAdded = true;
+                } else if (!pluginsProperty) {
+                    const newPluginsProperty = types_lib.objectProperty(types_lib.identifier('plugins'), types_lib.arrayExpression([
+                        types_lib.callExpression(types_lib.identifier('withZephyr'), [])
+                    ]));
+                    configObject.properties.push(newPluginsProperty);
+                    pluginAdded = true;
+                }
+            }
         }
     });
-    return hasPlugin;
+    if (!pluginAdded) addToPluginsArray(ast);
 }
 function addToComposePlugins(ast) {
     (0, traverse_lib["default"])(ast, {
@@ -48376,15 +48429,6 @@ function addToComposePlugins(ast) {
         }
     });
 }
-function addToPluginsArray(ast) {
-    (0, traverse_lib["default"])(ast, {
-        ObjectProperty (path) {
-            if (types_lib.isIdentifier(path.node.key, {
-                name: 'plugins'
-            }) && types_lib.isArrayExpression(path.node.value)) path.node.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
-        }
-    });
-}
 function addToVitePlugins(ast) {
     addToPluginsArray(ast);
 }
@@ -48410,13 +48454,112 @@ function addToVitePluginsInFunction(ast) {
         }
     });
 }
+function addToAstroIntegrations(ast) {
+    (0, traverse_lib["default"])(ast, {
+        ObjectExpression (path) {
+            for (const prop of path.node.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                name: 'integrations'
+            }) && types_lib.isArrayExpression(prop.value)) {
+                prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                path.stop();
+                return;
+            }
+        }
+    });
+}
+function addToAstroIntegrationsInFunction(ast) {
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isArrowFunctionExpression(path.node.arguments[0])) {
+                const arrowFunc = path.node.arguments[0];
+                let objExpr = null;
+                if (types_lib.isParenthesizedExpression(arrowFunc.body) && types_lib.isObjectExpression(arrowFunc.body.expression)) objExpr = arrowFunc.body.expression;
+                else if (types_lib.isObjectExpression(arrowFunc.body)) objExpr = arrowFunc.body;
+                if (objExpr) {
+                    for (const prop of objExpr.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                        name: 'integrations'
+                    }) && types_lib.isArrayExpression(prop.value)) {
+                        prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                        break;
+                    }
+                }
+            }
+        }
+    });
+}
+function addToAstroIntegrationsOrCreate(ast) {
+    let integrationAdded = false;
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isObjectExpression(path.node.arguments[0])) {
+                const configObject = path.node.arguments[0];
+                let integrationsProperty = null;
+                for (const prop of configObject.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                    name: 'integrations'
+                }) && types_lib.isArrayExpression(prop.value)) {
+                    integrationsProperty = prop;
+                    break;
+                }
+                if (integrationsProperty && types_lib.isArrayExpression(integrationsProperty.value)) {
+                    integrationsProperty.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                    integrationAdded = true;
+                } else if (!integrationsProperty) {
+                    const newIntegrationsProperty = types_lib.objectProperty(types_lib.identifier('integrations'), types_lib.arrayExpression([
+                        types_lib.callExpression(types_lib.identifier('withZephyr'), [])
+                    ]));
+                    configObject.properties.push(newIntegrationsProperty);
+                    integrationAdded = true;
+                }
+            }
+        }
+    });
+    if (!integrationAdded) addToAstroIntegrations(ast);
+}
+function addToAstroIntegrationsInFunctionOrCreate(ast) {
+    let integrationAdded = false;
+    (0, traverse_lib["default"])(ast, {
+        CallExpression (path) {
+            if (types_lib.isIdentifier(path.node.callee, {
+                name: 'defineConfig'
+            }) && 1 === path.node.arguments.length && types_lib.isArrowFunctionExpression(path.node.arguments[0])) {
+                const arrowFunc = path.node.arguments[0];
+                let objExpr = null;
+                if (types_lib.isParenthesizedExpression(arrowFunc.body) && types_lib.isObjectExpression(arrowFunc.body.expression)) objExpr = arrowFunc.body.expression;
+                else if (types_lib.isObjectExpression(arrowFunc.body)) objExpr = arrowFunc.body;
+                if (objExpr) {
+                    let integrationsProperty = null;
+                    for (const prop of objExpr.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                        name: 'integrations'
+                    }) && types_lib.isArrayExpression(prop.value)) {
+                        integrationsProperty = prop;
+                        break;
+                    }
+                    if (integrationsProperty && types_lib.isArrayExpression(integrationsProperty.value)) {
+                        integrationsProperty.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                        integrationAdded = true;
+                    } else if (!integrationsProperty) {
+                        const newIntegrationsProperty = types_lib.objectProperty(types_lib.identifier('integrations'), types_lib.arrayExpression([
+                            types_lib.callExpression(types_lib.identifier('withZephyr'), [])
+                        ]));
+                        objExpr.properties.push(newIntegrationsProperty);
+                        integrationAdded = true;
+                    }
+                }
+            }
+        }
+    });
+    if (!integrationAdded) addToAstroIntegrationsInFunction(ast);
+}
 function addToRollupFunction(ast) {
     (0, traverse_lib["default"])(ast, {
         ArrowFunctionExpression (path) {
-            if (1 === path.node.params.length && types_lib.isIdentifier(path.node.params[0], {
-                name: 'config'
-            })) {
-                const pushStatement = types_lib.expressionStatement(types_lib.callExpression(types_lib.memberExpression(types_lib.memberExpression(types_lib.identifier('config'), types_lib.identifier('plugins')), types_lib.identifier('push')), [
+            if (1 === path.node.params.length && types_lib.isIdentifier(path.node.params[0])) {
+                const paramName = path.node.params[0].name;
+                const pushStatement = types_lib.expressionStatement(types_lib.callExpression(types_lib.memberExpression(types_lib.memberExpression(types_lib.identifier(paramName), types_lib.identifier('plugins')), types_lib.identifier('push')), [
                     types_lib.callExpression(types_lib.identifier('withZephyr'), [])
                 ]));
                 if (types_lib.isBlockStatement(path.node.body)) {
@@ -48428,21 +48571,18 @@ function addToRollupFunction(ast) {
         }
     });
 }
-function addToRolldownPlugins(ast) {
-    addToPluginsArray(ast);
-}
-function addToModernJSPlugins(ast) {
-    addToPluginsArray(ast);
-}
-function addToRSPressPlugins(ast) {
-    addToPluginsArray(ast);
-}
-function addToParcelReporters(filePath, pluginName) {
-    const content = fs_0.readFileSync(filePath, 'utf8');
-    const config = JSON.parse(content);
-    if (!config.reporters) config.reporters = [];
-    if (!config.reporters.includes(pluginName)) config.reporters.push(pluginName);
-    fs_0.writeFileSync(filePath, JSON.stringify(config, null, 2));
+function addToRollupArrayConfig(ast) {
+    (0, traverse_lib["default"])(ast, {
+        ExportDefaultDeclaration (path) {
+            if (types_lib.isArrayExpression(path.node.declaration)) {
+                for (const element of path.node.declaration.elements)if (types_lib.isObjectExpression(element)) {
+                    for (const prop of element.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
+                        name: 'plugins'
+                    }) && types_lib.isArrayExpression(prop.value)) return void prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
+                }
+            }
+        }
+    });
 }
 function wrapModuleExports(ast) {
     (0, traverse_lib["default"])(ast, {
@@ -48451,7 +48591,9 @@ function wrapModuleExports(ast) {
                 name: 'module'
             }) && types_lib.isIdentifier(path.node.left.property, {
                 name: 'exports'
-            })) path.node.right = types_lib.callExpression(types_lib.identifier('withZephyr'), []);
+            })) path.node.right = types_lib.callExpression(types_lib.callExpression(types_lib.identifier('withZephyr'), []), [
+                path.node.right
+            ]);
         }
     });
 }
@@ -48464,20 +48606,6 @@ function wrapExportDefault(ast) {
         }
     });
 }
-function addToRollupArrayConfig(ast) {
-    (0, traverse_lib["default"])(ast, {
-        ExportDefaultDeclaration (path) {
-            if (types_lib.isArrayExpression(path.node.declaration)) {
-                for (const element of path.node.declaration.elements)if (types_lib.isObjectExpression(element)) {
-                    for (const prop of element.properties)if (types_lib.isObjectProperty(prop) && types_lib.isIdentifier(prop.key, {
-                        name: 'plugins'
-                    }) && types_lib.isArrayExpression(prop.value)) return void prop.value.elements.push(types_lib.callExpression(types_lib.identifier('withZephyr'), []));
-                }
-            }
-        }
-    });
-}
-function skipAlreadyWrapped(_ast) {}
 function wrapExportedFunction(ast) {
     (0, traverse_lib["default"])(ast, {
         ExportDefaultDeclaration (path) {
@@ -48498,122 +48626,50 @@ function wrapExportedFunction(ast) {
         }
     });
 }
-function addZephyrRSbuildPlugin(ast) {
-    let hasWithZephyrImport = false;
-    (0, traverse_lib["default"])(ast, {
-        ImportDeclaration (path) {
-            if ('zephyr-rspack-plugin' === path.node.source.value) {
-                const specifiers = path.node.specifiers;
-                for (const spec of specifiers)if (types_lib.isImportSpecifier(spec) && types_lib.isIdentifier(spec.imported, {
-                    name: 'withZephyr'
-                })) hasWithZephyrImport = true;
-            }
-        }
-    });
-    if (!hasWithZephyrImport) {
-        const importDeclaration = types_lib.importDeclaration([
-            types_lib.importSpecifier(types_lib.identifier('withZephyr'), types_lib.identifier('withZephyr'))
-        ], types_lib.stringLiteral('zephyr-rspack-plugin'));
-        (0, traverse_lib["default"])(ast, {
-            Program (path) {
-                const firstImportIndex = path.node.body.findIndex((node)=>types_lib.isImportDeclaration(node));
-                if (firstImportIndex >= 0) path.node.body.splice(firstImportIndex + 1, 0, importDeclaration);
-                else path.node.body.unshift(importDeclaration);
-                path.stop();
-            }
-        });
-    }
-    let hasZephyrPlugin = false;
-    (0, traverse_lib["default"])(ast, {
-        VariableDeclarator (path) {
-            if (types_lib.isIdentifier(path.node.id, {
-                name: 'zephyrRSbuildPlugin'
-            })) hasZephyrPlugin = true;
-        }
-    });
-    if (!hasZephyrPlugin) {
-        const zephyrPluginFunction = types_lib.variableDeclaration('const', [
-            types_lib.variableDeclarator(types_lib.identifier('zephyrRSbuildPlugin'), types_lib.arrowFunctionExpression([], types_lib.objectExpression([
-                types_lib.objectProperty(types_lib.identifier('name'), types_lib.stringLiteral('zephyr-rsbuild-plugin')),
-                types_lib.objectMethod('method', types_lib.identifier('setup'), [
-                    types_lib.identifier('api')
-                ], types_lib.blockStatement([
-                    types_lib.expressionStatement(types_lib.callExpression(types_lib.memberExpression(types_lib.identifier('api'), types_lib.identifier('modifyRspackConfig')), [
-                        types_lib.arrowFunctionExpression([
-                            types_lib.identifier('config')
-                        ], types_lib.blockStatement([
-                            types_lib.variableDeclaration('const', [
-                                types_lib.variableDeclarator(types_lib.identifier('zephyrConfig'), types_lib.awaitExpression(types_lib.callExpression(types_lib.callExpression(types_lib.identifier('withZephyr'), []), [
-                                    types_lib.identifier('config')
-                                ])))
-                            ]),
-                            types_lib.expressionStatement(types_lib.assignmentExpression('=', types_lib.identifier('config'), types_lib.identifier('zephyrConfig')))
-                        ]), true)
-                    ]))
-                ]))
-            ])))
-        ]);
-        (0, traverse_lib["default"])(ast, {
-            Program (path) {
-                let insertIndex = 0;
-                for(let i = 0; i < path.node.body.length; i++)if (types_lib.isImportDeclaration(path.node.body[i])) insertIndex = i + 1;
-                else break;
-                path.node.body.splice(insertIndex, 0, zephyrPluginFunction);
-                path.stop();
-            }
-        });
-        let hasRsbuildPluginImport = false;
-        (0, traverse_lib["default"])(ast, {
-            ImportDeclaration (path) {
-                if ('@rsbuild/core' === path.node.source.value) {
-                    const specifiers = path.node.specifiers;
-                    for (const spec of specifiers)if (types_lib.isImportSpecifier(spec) && types_lib.isIdentifier(spec.imported, {
-                        name: 'RsbuildPlugin'
-                    })) hasRsbuildPluginImport = true;
-                    if (!hasRsbuildPluginImport) specifiers.push(types_lib.importSpecifier(types_lib.identifier('RsbuildPlugin'), types_lib.identifier('RsbuildPlugin')));
-                }
-            }
-        });
-    }
-    (0, traverse_lib["default"])(ast, {
-        ObjectProperty (path) {
-            if (types_lib.isIdentifier(path.node.key, {
-                name: 'plugins'
-            }) && types_lib.isArrayExpression(path.node.value)) {
-                let hasZephyrInPlugins = false;
-                for (const element of path.node.value.elements)if (types_lib.isCallExpression(element) && types_lib.isIdentifier(element.callee, {
-                    name: 'zephyrRSbuildPlugin'
-                })) {
-                    hasZephyrInPlugins = true;
-                    break;
-                }
-                if (!hasZephyrInPlugins) path.node.value.elements.push(types_lib.callExpression(types_lib.identifier('zephyrRSbuildPlugin'), []));
-            }
-        }
-    });
+function addToParcelReporters(filePath, pluginName) {
+    const content = fs_0.readFileSync(filePath, 'utf8');
+    const config = JSON.parse(content);
+    if (!config.reporters) config.reporters = [];
+    if (!config.reporters.includes(pluginName)) config.reporters.push(pluginName);
+    fs_0.writeFileSync(filePath, JSON.stringify(config, null, 2));
 }
+const src_BUNDLER_CONFIGS = {
+    webpack: webpack_webpackConfig,
+    rspack: rspack_rspackConfig,
+    vite: vite_viteConfig,
+    rollup: rollup_rollupConfig,
+    rolldown: rolldown_rolldownConfig,
+    rsbuild: rsbuild_rsbuildConfig,
+    rslib: rslib_rslibConfig,
+    parcel: parcel_parcelConfig,
+    astro: astro_astroConfig,
+    modernjs: modernjs_modernjsConfig,
+    rspress: rspress_rspressConfig,
+    repack: repack_repackConfig
+};
 const TRANSFORMERS = {
     addToComposePlugins: addToComposePlugins,
     addToPluginsArray: addToPluginsArray,
+    addToPluginsArrayOrCreate: addToPluginsArrayOrCreate,
     addToVitePlugins: addToVitePlugins,
     addToVitePluginsInFunction: addToVitePluginsInFunction,
+    addToAstroIntegrations: addToAstroIntegrations,
+    addToAstroIntegrationsInFunction: addToAstroIntegrationsInFunction,
+    addToAstroIntegrationsOrCreate: addToAstroIntegrationsOrCreate,
+    addToAstroIntegrationsInFunctionOrCreate: addToAstroIntegrationsInFunctionOrCreate,
     addToRollupFunction: addToRollupFunction,
     addToRollupArrayConfig: addToRollupArrayConfig,
-    addToRolldownPlugins: addToRolldownPlugins,
-    addToModernJSPlugins: addToModernJSPlugins,
-    addToRSPressPlugins: addToRSPressPlugins,
     wrapModuleExports: wrapModuleExports,
     wrapExportDefault: wrapExportDefault,
     skipAlreadyWrapped: skipAlreadyWrapped,
-    wrapExportedFunction: wrapExportedFunction,
-    addZephyrRSbuildPlugin: addZephyrRSbuildPlugin
+    wrapExportedFunction: wrapExportedFunction
 };
 function normalizePathForOutput(filePath) {
     return filePath.replace(/\\/g, '/');
 }
 function findConfigFiles(directory) {
     const configFiles = [];
-    for (const [bundlerName, config] of Object.entries(BUNDLER_CONFIGS))for (const fileName of config.files){
+    for (const [bundlerName, config] of Object.entries(src_BUNDLER_CONFIGS))for (const fileName of config.files){
         const pattern = `${directory}/**/${fileName}`.replace(/\\/g, '/');
         const matches = esm_glob.sync(pattern, {
             ignore: [
@@ -48656,7 +48712,7 @@ function checkHasZephyr(filePath, config) {
         }
         {
             const ast = parseFile(filePath);
-            return transformers_hasZephyrPlugin(ast);
+            return hasZephyrPlugin(ast);
         }
     } catch (error) {
         console.warn(source.yellow(`Warning: Could not parse ${normalizePathForOutput(filePath)}: ${error.message}`));

package/dist/zephyr-manifest.json

@@ -0,0 +1,6 @@
+{
+  "version": "1.0.0",
+  "timestamp": "2025-10-29T15:11:47.671Z",
+  "dependencies": {},
+  "zeVars": {}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "with-zephyr",
-  "version": "0.1.0-next.1",
+  "version": "0.1.1-next.2",
   "description": "A codemod to automatically add withZephyr plugin to bundler configurations",
   "main": "dist/index.js",
   "repository": {
@@ -38,7 +38,7 @@
     "@types/node": "^24.5.2",
     "@rslib/core": "^0.13.3",
     "typescript": "^5.9.2",
-    "zephyr-rsbuild-plugin": "0.1.0-next.1"
+    "zephyr-rsbuild-plugin": "0.1.1-next.2"
   },
   "keywords": [
     "zephyr",
@@ -50,6 +50,7 @@
     "rspack",
     "rsbuild",
     "rslib",
+    "astro",
     "modernjs",
     "rolldown",
     "rspress"