@next/codemod 15.0.0-canary.19 → 15.0.0-canary.190

package/bin/next-codemod.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+"use strict";
 /**
  * Copyright 2015-present, Facebook, Inc.
  *
@@ -6,7 +7,44 @@
  * LICENSE file in the root directory of this source tree.
  *
  */
-// Based on https://github.com/reactjs/react-codemod/blob/dd8671c9a470a2c342b221ec903c574cf31e9f57/bin/react-codemod.js
-// next-codemod optional-name-of-transform optional/path/to/src [...options]
-require('./cli').run();
+// Based on https://github.com/reactjs/react-codemod/blob/dd8671c9a470a2c342b221ec903c574cf31e9f57/bin/cli.js
+// @next/codemod optional-name-of-transform optional/path/to/src [...options]
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const upgrade_1 = require("./upgrade");
+const transform_1 = require("./transform");
+const packageJson = require('../package.json');
+const program = new commander_1.Command(packageJson.name)
+    .description('Codemods for updating Next.js apps.')
+    .version(packageJson.version, '-v, --version', 'Output the current version of @next/codemod.')
+    .argument('[codemod]', 'Codemod slug to run. See "https://github.com/vercel/next.js/tree/canary/packages/next-codemod".')
+    .argument('[source]', 'Path to source files or directory to transform including glob patterns.')
+    .usage('[codemod] [source] [options]')
+    .helpOption('-h, --help', 'Display this help message.')
+    .option('-f, --force', 'Bypass Git safety checks and forcibly run codemods')
+    .option('-d, --dry', 'Dry run (no changes are made to files)')
+    .option('-p, --print', 'Print transformed files to stdout, useful for development')
+    .option('--verbose', 'Show more information about the transform process')
+    .option('-j, --jscodeshift', '(Advanced) Pass options directly to jscodeshift')
+    .action(transform_1.runTransform)
+    .allowUnknownOption()
+    // This is needed for options for subcommands to be passed correctly.
+    // Because by default the options are not positional, which will pass options
+    // to the main command "@next/codemod" even if it was passed after subcommands,
+    // e.g. "@next/codemod upgrade --verbose" will be treated as "next-codemod --verbose upgrade"
+    // By enabling this, it will respect the position of the options and pass it to subcommands.
+    // x-ref: https://github.com/tj/commander.js/pull/1427
+    .enablePositionalOptions();
+program
+    .command('upgrade')
+    .description('Upgrade Next.js apps to desired versions with a single command.')
+    .argument('[revision]', 'Specify the target Next.js version using an NPM dist tag (e.g. "latest", "canary", "rc") or an exact version number (e.g. "15.0.0").', packageJson.version.includes('-canary.')
+    ? 'canary'
+    : packageJson.version.includes('-rc.')
+        ? 'rc'
+        : 'latest')
+    .usage('[revision] [options]')
+    .option('--verbose', 'Verbose output', false)
+    .action(upgrade_1.runUpgrade);
+program.parse(process.argv);
 //# sourceMappingURL=next-codemod.js.map

package/bin/transform.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformerDirectory = exports.jscodeshiftExecutable = void 0;
+exports.runTransform = runTransform;
+const execa_1 = __importDefault(require("execa"));
+const globby_1 = __importDefault(require("globby"));
+const prompts_1 = __importDefault(require("prompts"));
+const node_path_1 = require("node:path");
+const handle_package_1 = require("../lib/handle-package");
+const utils_1 = require("../lib/utils");
+function expandFilePathsIfNeeded(filesBeforeExpansion) {
+    const shouldExpandFiles = filesBeforeExpansion.some((file) => file.includes('*'));
+    return shouldExpandFiles
+        ? globby_1.default.sync(filesBeforeExpansion)
+        : filesBeforeExpansion;
+}
+exports.jscodeshiftExecutable = require.resolve('.bin/jscodeshift');
+exports.transformerDirectory = (0, node_path_1.join)(__dirname, '../', 'transforms');
+async function runTransform(transform, path, options) {
+    let transformer = transform;
+    let directory = path;
+    if (!options.dry) {
+        (0, utils_1.checkGitStatus)(options.force);
+    }
+    if (transform &&
+        !utils_1.TRANSFORMER_INQUIRER_CHOICES.find((x) => x.value === transform)) {
+        console.error('Invalid transform choice, pick one of:');
+        console.error(utils_1.TRANSFORMER_INQUIRER_CHOICES.map((x) => '- ' + x.value).join('\n'));
+        process.exit(1);
+    }
+    if (!path) {
+        const res = await (0, prompts_1.default)({
+            type: 'text',
+            name: 'path',
+            message: 'On which files or directory should the codemods be applied?',
+            initial: '.',
+        }, { onCancel: utils_1.onCancel });
+        directory = res.path;
+    }
+    if (!transform) {
+        const res = await (0, prompts_1.default)({
+            type: 'select',
+            name: 'transformer',
+            message: 'Which transform would you like to apply?',
+            choices: utils_1.TRANSFORMER_INQUIRER_CHOICES.reverse().map(({ title, value, version }) => {
+                return {
+                    title: `(v${version}) ${value}`,
+                    description: title,
+                    value,
+                };
+            }),
+        }, { onCancel: utils_1.onCancel });
+        transformer = res.transformer;
+    }
+    const filesExpanded = expandFilePathsIfNeeded([directory]);
+    if (!filesExpanded.length) {
+        console.log(`No files found matching "${directory}"`);
+        return null;
+    }
+    const transformerPath = (0, node_path_1.join)(exports.transformerDirectory, `${transformer}.js`);
+    if (transformer === 'cra-to-next') {
+        // cra-to-next transform doesn't use jscodeshift directly
+        return require(transformerPath).default(filesExpanded, options);
+    }
+    let args = [];
+    const { dry, print, runInBand, jscodeshift, verbose } = options;
+    if (dry) {
+        args.push('--dry');
+    }
+    if (print) {
+        args.push('--print');
+    }
+    if (runInBand) {
+        args.push('--run-in-band');
+    }
+    if (verbose) {
+        args.push('--verbose=2');
+    }
+    args.push('--no-babel');
+    args.push('--ignore-pattern=**/node_modules/**');
+    args.push('--ignore-pattern=**/.next/**');
+    args.push('--extensions=tsx,ts,jsx,js');
+    args = args.concat(['--transform', transformerPath]);
+    if (jscodeshift) {
+        args = args.concat(jscodeshift);
+    }
+    args = args.concat(filesExpanded);
+    console.log(`Executing command: jscodeshift ${args.join(' ')}`);
+    const result = execa_1.default.sync(exports.jscodeshiftExecutable, args, {
+        stdio: 'inherit',
+        stripFinalNewline: false,
+    });
+    if (result.failed) {
+        throw new Error(`jscodeshift exited with code ${result.exitCode}`);
+    }
+    if (!dry && transformer === 'built-in-next-font') {
+        const { uninstallNextFont } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'uninstallNextFont',
+            message: 'Do you want to uninstall `@next/font`?',
+            initial: true,
+        });
+        if (uninstallNextFont) {
+            console.log('Uninstalling `@next/font`');
+            (0, handle_package_1.uninstallPackage)('@next/font');
+        }
+    }
+    if (!dry && transformer === 'next-request-geo-ip') {
+        const { installVercelFunctions } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'installVercelFunctions',
+            message: 'Do you want to install `@vercel/functions`?',
+            initial: true,
+        });
+        if (installVercelFunctions) {
+            console.log('Installing `@vercel/functions`...');
+            (0, handle_package_1.installPackages)(['@vercel/functions']);
+        }
+    }
+}
+//# sourceMappingURL=transform.js.map

package/bin/upgrade.js

@@ -0,0 +1,290 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpgrade = runUpgrade;
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+const semver_1 = __importDefault(require("semver"));
+const compare_1 = __importDefault(require("semver/functions/compare"));
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const handle_package_1 = require("../lib/handle-package");
+const transform_1 = require("./transform");
+const utils_1 = require("../lib/utils");
+/**
+ * @param query
+ * @example loadHighestNPMVersionMatching("react@^18.3.0 || ^19.0.0") === Promise<"19.0.0">
+ */
+async function loadHighestNPMVersionMatching(query) {
+    const versionsJSON = (0, child_process_1.execSync)(`npm --silent view "${query}" --json --field version`, { encoding: 'utf-8' });
+    const versionOrVersions = JSON.parse(versionsJSON);
+    if (versionOrVersions.length < 1) {
+        throw new Error(`Found no React versions matching "${query}". This is a bug in the upgrade tool.`);
+    }
+    // npm-view returns an array if there are multiple versions matching the query.
+    if (Array.isArray(versionOrVersions)) {
+        // The last entry will be the latest version published.
+        return versionOrVersions[versionOrVersions.length - 1];
+    }
+    return versionOrVersions;
+}
+async function runUpgrade(revision, options) {
+    const { verbose } = options;
+    const appPackageJsonPath = path_1.default.resolve(process.cwd(), 'package.json');
+    let appPackageJson = JSON.parse(fs_1.default.readFileSync(appPackageJsonPath, 'utf8'));
+    let targetNextPackageJson;
+    const res = await fetch(`https://registry.npmjs.org/next/${revision}`);
+    if (res.status === 200) {
+        targetNextPackageJson = await res.json();
+    }
+    const validRevision = targetNextPackageJson !== null &&
+        typeof targetNextPackageJson === 'object' &&
+        'version' in targetNextPackageJson &&
+        'peerDependencies' in targetNextPackageJson;
+    if (!validRevision) {
+        throw new Error(`Invalid revision provided: "${revision}". Please provide a valid Next.js version or dist-tag (e.g. "latest", "canary", "rc", or "15.0.0").\nCheck available versions at https://www.npmjs.com/package/next?activeTab=versions.`);
+    }
+    const installedNextVersion = getInstalledNextVersion();
+    console.log(`Current Next.js version: v${installedNextVersion}`);
+    const targetNextVersion = targetNextPackageJson.version;
+    if ((0, compare_1.default)(installedNextVersion, targetNextVersion) === 0) {
+        console.log(`${picocolors_1.default.green('✓')} Current Next.js version is already on the target version "v${targetNextVersion}".`);
+        return;
+    }
+    if ((0, compare_1.default)(installedNextVersion, targetNextVersion) > 0) {
+        console.log(`${picocolors_1.default.green('✓')} Current Next.js version is higher than the target version "v${targetNextVersion}".`);
+        return;
+    }
+    const installedReactVersion = getInstalledReactVersion();
+    console.log(`Current React version: v${installedReactVersion}`);
+    let shouldStayOnReact18 = false;
+    if (
+    // From release v14.3.0-canary.45, Next.js expects the React version to be 19.0.0-beta.0
+    // If the user is on a version higher than this but is still on React 18, we ask them
+    // if they still want to stay on React 18 after the upgrade.
+    // IF THE USER USES APP ROUTER, we expect them to upgrade React to > 19.0.0-beta.0,
+    // we should only let the user stay on React 18 if they are using pure Pages Router.
+    // x-ref(PR): https://github.com/vercel/next.js/pull/65058
+    // x-ref(release): https://github.com/vercel/next.js/releases/tag/v14.3.0-canary.45
+    (0, compare_1.default)(installedNextVersion, '14.3.0-canary.45') >= 0 &&
+        installedReactVersion.startsWith('18')) {
+        const shouldStayOnReact18Res = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'shouldStayOnReact18',
+            message: `Are you using ${picocolors_1.default.underline('only the Pages Router')} (no App Router) and prefer to stay on React 18?`,
+            initial: false,
+            active: 'Yes',
+            inactive: 'No',
+        }, { onCancel: utils_1.onCancel });
+        shouldStayOnReact18 = shouldStayOnReact18Res.shouldStayOnReact18;
+    }
+    // We're resolving a specific version here to avoid including "ugly" version queries
+    // in the manifest.
+    // E.g. in peerDependencies we could have `^18.2.0 || ^19.0.0 || 20.0.0-canary`
+    // If we'd just `npm add` that, the manifest would read the same version query.
+    // This is basically a `npm --save-exact react@$versionQuery` that works for every package manager.
+    const targetReactVersion = shouldStayOnReact18
+        ? '18.3.1'
+        : await loadHighestNPMVersionMatching(`react@${targetNextPackageJson.peerDependencies['react']}`);
+    if ((0, compare_1.default)(targetNextVersion, '15.0.0-canary') >= 0) {
+        await suggestTurbopack(appPackageJson);
+    }
+    const codemods = await suggestCodemods(installedNextVersion, targetNextVersion);
+    const packageManager = (0, handle_package_1.getPkgManager)(process.cwd());
+    let shouldRunReactCodemods = false;
+    let shouldRunReactTypesCodemods = false;
+    let execCommand = 'npx';
+    // The following React codemods are for React 19
+    if (!shouldStayOnReact18 &&
+        (0, compare_1.default)(targetReactVersion, '19.0.0-beta.0') >= 0) {
+        shouldRunReactCodemods = await suggestReactCodemods();
+        shouldRunReactTypesCodemods = await suggestReactTypesCodemods();
+        const execCommandMap = {
+            yarn: 'yarn dlx',
+            pnpm: 'pnpx',
+            bun: 'bunx',
+            npm: 'npx',
+        };
+        execCommand = execCommandMap[packageManager];
+    }
+    fs_1.default.writeFileSync(appPackageJsonPath, JSON.stringify(appPackageJson, null, 2));
+    const nextDependency = `next@${targetNextVersion}`;
+    const reactDependencies = [
+        `react@${targetReactVersion}`,
+        `react-dom@${targetReactVersion}`,
+    ];
+    if (targetReactVersion.startsWith('19.0.0-canary') ||
+        targetReactVersion.startsWith('19.0.0-beta') ||
+        targetReactVersion.startsWith('19.0.0-rc')) {
+        reactDependencies.push(`@types/react@npm:types-react@rc`);
+        reactDependencies.push(`@types/react-dom@npm:types-react-dom@rc`);
+    }
+    else {
+        const [targetReactTypesVersion, targetReactDOMTypesVersion] = await Promise.all([
+            loadHighestNPMVersionMatching(`@types/react@${targetNextPackageJson.peerDependencies['react']}`),
+            loadHighestNPMVersionMatching(`@types/react-dom@${targetNextPackageJson.peerDependencies['react']}`),
+        ]);
+        reactDependencies.push(`@types/react@${targetReactTypesVersion}`);
+        reactDependencies.push(`@types/react-dom@${targetReactDOMTypesVersion}`);
+    }
+    console.log(`Upgrading your project to ${picocolors_1.default.blue('Next.js ' + targetNextVersion)}...\n`);
+    (0, handle_package_1.installPackages)([nextDependency, ...reactDependencies], {
+        packageManager,
+        silent: !verbose,
+    });
+    for (const codemod of codemods) {
+        await (0, transform_1.runTransform)(codemod, process.cwd(), { force: true, verbose });
+    }
+    // To reduce user-side burden of selecting which codemods to run as it needs additional
+    // understanding of the codemods, we run all of the applicable codemods.
+    if (shouldRunReactCodemods) {
+        // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#run-all-react-19-codemods
+        (0, child_process_1.execSync)(
+        // `--no-interactive` skips the interactive prompt that asks for confirmation
+        // https://github.com/codemod-com/codemod/blob/c0cf00d13161a0ec0965b6cc6bc5d54076839cc8/apps/cli/src/flags.ts#L160
+        `${execCommand} codemod@latest react/19/migration-recipe --no-interactive`, { stdio: 'inherit' });
+    }
+    if (shouldRunReactTypesCodemods) {
+        // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#typescript-changes
+        // `--yes` skips prompts and applies all codemods automatically
+        // https://github.com/eps1lon/types-react-codemod/blob/8463103233d6b70aad3cd6bee1814001eae51b28/README.md?plain=1#L52
+        (0, child_process_1.execSync)(`${execCommand} types-react-codemod@latest --yes preset-19 .`, {
+            stdio: 'inherit',
+        });
+    }
+    console.log(); // new line
+    if (codemods.length > 0) {
+        console.log(`${picocolors_1.default.green('✔')} Codemods have been applied successfully.`);
+    }
+    console.log(`Please review the local changes and read the Next.js 15 migration guide to complete the migration. https://nextjs.org/docs/canary/app/building-your-application/upgrading/version-15`);
+}
+function getInstalledNextVersion() {
+    try {
+        return require(require.resolve('next/package.json', {
+            paths: [process.cwd()],
+        })).version;
+    }
+    catch (error) {
+        throw new Error(`Failed to get the installed Next.js version at "${process.cwd()}".\nIf you're using a monorepo, please run this command from the Next.js app directory.`, {
+            cause: error,
+        });
+    }
+}
+function getInstalledReactVersion() {
+    try {
+        return require(require.resolve('react/package.json', {
+            paths: [process.cwd()],
+        })).version;
+    }
+    catch (error) {
+        throw new Error(`Failed to detect the installed React version in "${process.cwd()}".\nIf you're working in a monorepo, please run this command from the Next.js app directory.`, {
+            cause: error,
+        });
+    }
+}
+/*
+ * Heuristics are used to determine whether to Turbopack is enabled or not and
+ * to determine how to update the dev script.
+ *
+ * 1. If the dev script contains `--turbo` option, we assume that Turbopack is
+ *    already enabled.
+ * 2. If the dev script contains the string `next dev`, we replace it to
+ *    `next dev --turbo`.
+ * 3. Otherwise, we ask the user to manually add `--turbo` to their dev command,
+ *    showing the current dev command as the initial value.
+ */
+async function suggestTurbopack(packageJson) {
+    const devScript = packageJson.scripts['dev'];
+    if (devScript.includes('--turbo'))
+        return;
+    const responseTurbopack = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'enable',
+        message: 'Enable Turbopack for next dev?',
+        initial: true,
+    }, { onCancel: utils_1.onCancel });
+    if (!responseTurbopack.enable) {
+        return;
+    }
+    if (devScript.includes('next dev')) {
+        packageJson.scripts['dev'] = devScript.replace('next dev', 'next dev --turbo');
+        return;
+    }
+    console.log(`${picocolors_1.default.yellow('⚠')} Could not find "${picocolors_1.default.bold('next dev')}" in your dev script.`);
+    const responseCustomDevScript = await (0, prompts_1.default)({
+        type: 'text',
+        name: 'customDevScript',
+        message: 'Please manually add "--turbo" to your dev command.',
+        initial: devScript,
+    }, { onCancel: utils_1.onCancel });
+    packageJson.scripts['dev'] =
+        responseCustomDevScript.customDevScript || devScript;
+}
+async function suggestCodemods(initialNextVersion, targetNextVersion) {
+    // Here we suggest pre-released codemods by their "stable" version.
+    // It is because if we suggest by the version range (installed ~ target),
+    // pre-released codemods for the target version are not suggested when upgrading.
+    // Let's say we have a codemod for v15.0.0-canary.x, and we're upgrading from
+    // v15.x -> v15.x. Our initial version is higher than the codemod's version,
+    // so the codemod will not be suggested.
+    // This is not ideal as the codemods for pre-releases are also targeting the major version.
+    // Also, when the user attempts to run the upgrade command twice, and have installed the
+    // target version, the behavior must be idempotent and suggest the codemods including the
+    // pre-releases of the target version.
+    const initial = semver_1.default.parse(initialNextVersion);
+    const initialVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((versionCodemods) => {
+        const codemod = semver_1.default.parse(versionCodemods.version);
+        return ((0, compare_1.default)(`${codemod.major}.${codemod.minor}.${codemod.patch}`, `${initial.major}.${initial.minor}.${initial.patch}`) >= 0);
+    });
+    if (initialVersionIndex === -1) {
+        return [];
+    }
+    let targetVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((versionCodemods) => (0, compare_1.default)(versionCodemods.version, targetNextVersion) > 0);
+    if (targetVersionIndex === -1) {
+        targetVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.length;
+    }
+    const relevantCodemods = utils_1.TRANSFORMER_INQUIRER_CHOICES.slice(initialVersionIndex, targetVersionIndex);
+    if (relevantCodemods.length === 0) {
+        return [];
+    }
+    const { codemods } = await (0, prompts_1.default)({
+        type: 'multiselect',
+        name: 'codemods',
+        message: `The following ${picocolors_1.default.blue('codemods')} are recommended for your upgrade. Select the ones to apply.`,
+        choices: relevantCodemods.reverse().map(({ title, value, version }) => {
+            return {
+                title: `(v${version}) ${value}`,
+                description: title,
+                value,
+                selected: true,
+            };
+        }),
+    }, { onCancel: utils_1.onCancel });
+    return codemods;
+}
+async function suggestReactCodemods() {
+    const { runReactCodemod } = await (0, prompts_1.default)({
+        type: 'toggle',
+        name: 'runReactCodemod',
+        message: 'Would you like to run the React 19 upgrade codemod?',
+        initial: true,
+        active: 'Yes',
+        inactive: 'No',
+    }, { onCancel: utils_1.onCancel });
+    return runReactCodemod;
+}
+async function suggestReactTypesCodemods() {
+    const { runReactTypesCodemod } = await (0, prompts_1.default)({
+        type: 'toggle',
+        name: 'runReactTypesCodemod',
+        message: 'Would you like to run the React 19 Types upgrade codemod?',
+        initial: true,
+        active: 'Yes',
+        inactive: 'No',
+    }, { onCancel: utils_1.onCancel });
+    return runReactTypesCodemod;
+}
+//# sourceMappingURL=upgrade.js.map

package/lib/cra-to-next/global-css-transform.js

@@ -4,14 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalCssContext = void 0;
+exports.default = transformer;
 const path_1 = __importDefault(require("path"));
+const parser_1 = require("../parser");
 exports.globalCssContext = {
     cssImports: new Set(),
     reactSvgImports: new Set(),
 };
 const globalStylesRegex = /(?<!\.module)\.(css|scss|sass)$/i;
-function transformer(file, api, options) {
-    const j = api.jscodeshift.withParser('tsx');
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
     let hasModifications = false;
     root
@@ -37,8 +39,7 @@ function transformer(file, api, options) {
             }
             else if (value.endsWith('.svg')) {
                 const isComponentImport = path.node.specifiers.some((specifier) => {
-                    var _a;
-                    return ((_a = specifier.imported) === null || _a === void 0 ? void 0 : _a.name) === 'ReactComponent';
+                    return specifier.imported?.name === 'ReactComponent';
                 });
                 if (isComponentImport) {
                     exports.globalCssContext.reactSvgImports.add(file.path);
@@ -52,5 +53,4 @@ function transformer(file, api, options) {
         ? root.toSource(options)
         : null;
 }
-exports.default = transformer;
 //# sourceMappingURL=global-css-transform.js.map

package/lib/cra-to-next/index-to-component.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexContext = void 0;
+exports.default = transformer;
+const parser_1 = require("../parser");
 exports.indexContext = {
     multipleRenderRoots: false,
     nestedRender: false,
 };
-function transformer(file, api, options) {
-    const j = api.jscodeshift.withParser('tsx');
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
     let hasModifications = false;
     let foundReactRender = 0;
@@ -28,7 +30,6 @@ function transformer(file, api, options) {
     root
         .find(j.CallExpression)
         .filter((path) => {
-        var _a, _b;
         const { node } = path;
         let found = false;
         if (defaultReactDomImport &&
@@ -43,7 +44,7 @@ function transformer(file, api, options) {
         if (found) {
             foundReactRender++;
             hasModifications = true;
-            if (!Array.isArray((_b = (_a = path.parentPath) === null || _a === void 0 ? void 0 : _a.parentPath) === null || _b === void 0 ? void 0 : _b.value)) {
+            if (!Array.isArray(path.parentPath?.parentPath?.value)) {
                 exports.indexContext.nestedRender = true;
                 return false;
             }
@@ -73,5 +74,4 @@ function transformer(file, api, options) {
     // }).remove()
     return hasModifications ? root.toSource(options) : null;
 }
-exports.default = transformer;
 //# sourceMappingURL=index-to-component.js.map

package/lib/handle-package.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPkgManager = getPkgManager;
+exports.uninstallPackage = uninstallPackage;
+exports.installPackages = installPackages;
+const find_up_1 = __importDefault(require("find-up"));
+const execa_1 = __importDefault(require("execa"));
+const node_path_1 = require("node:path");
+function getPkgManager(baseDir) {
+    try {
+        const lockFile = find_up_1.default.sync(['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb'], { cwd: baseDir });
+        if (lockFile) {
+            switch ((0, node_path_1.basename)(lockFile)) {
+                case 'package-lock.json':
+                    return 'npm';
+                case 'yarn.lock':
+                    return 'yarn';
+                case 'pnpm-lock.yaml':
+                    return 'pnpm';
+                case 'bun.lockb':
+                    return 'bun';
+                default:
+                    return 'npm';
+            }
+        }
+    }
+    catch {
+        return 'npm';
+    }
+}
+function uninstallPackage(packageToUninstall, pkgManager) {
+    pkgManager ??= getPkgManager(process.cwd());
+    if (!pkgManager)
+        throw new Error('Failed to find package manager');
+    let command = 'uninstall';
+    if (pkgManager === 'yarn') {
+        command = 'remove';
+    }
+    try {
+        execa_1.default.sync(pkgManager, [command, packageToUninstall], { stdio: 'inherit' });
+    }
+    catch (error) {
+        throw new Error(`Failed to uninstall "${packageToUninstall}". Please uninstall it manually.`, { cause: error });
+    }
+}
+function installPackages(packageToInstall, options = {}) {
+    const { packageManager = getPkgManager(process.cwd()), silent = false } = options;
+    if (!packageManager)
+        throw new Error('Failed to find package manager');
+    try {
+        execa_1.default.sync(packageManager, ['add', ...packageToInstall], {
+            // Keeping stderr since it'll likely be relevant later when it fails.
+            stdio: silent ? ['ignore', 'ignore', 'inherit'] : 'inherit',
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to install "${packageToInstall}". Please install it manually.`, { cause: error });
+    }
+}
+//# sourceMappingURL=handle-package.js.map

package/lib/install.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.install = void 0;
+exports.install = install;
 /* eslint-disable import/no-extraneous-dependencies */
 const picocolors_1 = require("picocolors");
 const cross_spawn_1 = __importDefault(require("cross-spawn"));
@@ -84,7 +84,7 @@ function install(root, dependencies, { useYarn, isOnline, devDependencies }) {
          */
         const child = (0, cross_spawn_1.default)(command, args, {
             stdio: 'inherit',
-            env: Object.assign(Object.assign({}, process.env), { ADBLOCK: '1', DISABLE_OPENCOLLECTIVE: '1' }),
+            env: { ...process.env, ADBLOCK: '1', DISABLE_OPENCOLLECTIVE: '1' },
         });
         child.on('close', (code) => {
             if (code !== 0) {
@@ -95,5 +95,4 @@ function install(root, dependencies, { useYarn, isOnline, devDependencies }) {
         });
     });
 }
-exports.install = install;
 //# sourceMappingURL=install.js.map

package/lib/parser.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParserFromPath = createParserFromPath;
+const jscodeshift_1 = __importDefault(require("jscodeshift"));
+const babylon_1 = __importDefault(require("jscodeshift/parser/babylon"));
+const tsOptions_1 = __importDefault(require("jscodeshift/parser/tsOptions"));
+const dtsOptions = {
+    ...tsOptions_1.default,
+    plugins: [
+        ...tsOptions_1.default.plugins.filter((plugin) => plugin !== 'typescript'),
+        ['typescript', { dts: true }],
+    ],
+};
+function createParserFromPath(filePath) {
+    const isDeclarationFile = /\.d\.(m|c)?ts$/.test(filePath);
+    if (isDeclarationFile) {
+        return jscodeshift_1.default.withParser((0, babylon_1.default)(dtsOptions));
+    }
+    // jsx is allowed in .js files, feed them into the tsx parser.
+    // tsx parser :.js, .jsx, .tsx
+    // ts parser: .ts, .mts, .cts
+    const isTsFile = /\.(m|c)?.ts$/.test(filePath);
+    return isTsFile ? jscodeshift_1.default.withParser('ts') : jscodeshift_1.default.withParser('tsx');
+}
+//# sourceMappingURL=parser.js.map