@next/codemod 15.0.0-rc.0 → 15.0.0

package/bin/next-codemod.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+"use strict";
 /**
  * Copyright 2015-present, Facebook, Inc.
  *
@@ -6,7 +7,58 @@
  * 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 shared_1 = require("./shared");
+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(async (revision, options) => {
+    try {
+        await (0, upgrade_1.runUpgrade)(revision, options);
+    }
+    catch (error) {
+        if (!options.verbose && error instanceof shared_1.BadInput) {
+            console.error(error.message);
+        }
+        else {
+            console.error(error);
+        }
+        process.exit(1);
+    }
+});
+program.parse(process.argv);
 //# sourceMappingURL=next-codemod.js.map

package/bin/shared.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadInput = void 0;
+class BadInput extends Error {
+}
+exports.BadInput = BadInput;
+//# sourceMappingURL=shared.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,473 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUpgrade = runUpgrade;
+const os = __importStar(require("os"));
+const prompts_1 = __importDefault(require("prompts"));
+const fs_1 = __importDefault(require("fs"));
+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");
+const shared_1 = require("./shared");
+const optionalNextjsPackages = [
+    'create-next-app',
+    'eslint-config-next',
+    '@next/bundle-analyzer',
+    '@next/codemod',
+    '@next/env',
+    '@next/eslint-plugin-next',
+    '@next/font',
+    '@next/mdx',
+    '@next/plugin-storybook',
+    '@next/polyfill-module',
+    '@next/polyfill-nomodule',
+    '@next/swc',
+    '@next/react-refresh-utils',
+    '@next/third-parties',
+];
+/**
+ * @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;
+}
+function endMessage() {
+    console.log();
+    console.log(picocolors_1.default.white(picocolors_1.default.bold(`Please review the local changes and read the Next.js 15 migration guide to complete the migration.`)));
+    console.log(picocolors_1.default.underline('https://nextjs.org/docs/canary/app/building-your-application/upgrading/version-15'));
+}
+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 shared_1.BadInput(`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();
+    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}".`);
+        endMessage();
+        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}".`);
+        endMessage();
+        return;
+    }
+    const installedReactVersion = getInstalledReactVersion();
+    // Align the prefix spaces
+    console.log(`  Detected installed versions:`);
+    console.log(`  - React: v${installedReactVersion}`);
+    console.log(`  - Next.js: v${installedNextVersion}`);
+    let shouldStayOnReact18 = false;
+    const usesAppDir = isUsingAppDir(process.cwd());
+    const usesPagesDir = isUsingPagesDir(process.cwd());
+    const isPureAppRouter = usesAppDir && !usesPagesDir;
+    const isMixedApp = usesPagesDir && usesAppDir;
+    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)(targetNextVersion, '14.3.0-canary.45') >= 0 &&
+        installedReactVersion.startsWith('18') &&
+        // Pure App Router always uses React 19
+        // The mixed case is tricky to handle from a types perspective.
+        // We'll recommend to upgrade in the prompt but users can decide to try 18.
+        !isPureAppRouter) {
+        const shouldStayOnReact18Res = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'shouldStayOnReact18',
+            message: `Do you prefer to stay on React 18?` +
+                (isMixedApp
+                    ? " Since you're using both pages/ and app/, we recommend upgrading React to use a consistent version throughout your app."
+                    : ''),
+            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-0') >= 0 &&
+        (0, compare_1.default)(installedReactVersion, '19.0.0-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 dependenciesToInstall = [];
+    const devDependenciesToInstall = [];
+    const allDependencies = {
+        ...appPackageJson.dependencies,
+        ...appPackageJson.devDependencies,
+    };
+    const versionMapping = {
+        next: { version: targetNextVersion, required: true },
+        react: { version: targetReactVersion, required: true },
+        'react-dom': { version: targetReactVersion, required: true },
+        'react-is': { version: targetReactVersion, required: false },
+    };
+    for (const optionalNextjsPackage of optionalNextjsPackages) {
+        versionMapping[optionalNextjsPackage] = {
+            version: targetNextVersion,
+            required: false,
+        };
+    }
+    if (targetReactVersion.startsWith('19.0.0-canary') ||
+        targetReactVersion.startsWith('19.0.0-beta') ||
+        targetReactVersion.startsWith('19.0.0-rc')) {
+        const [targetReactTypesVersion, targetReactDOMTypesVersion] = await Promise.all([
+            loadHighestNPMVersionMatching(`types-react@rc`),
+            loadHighestNPMVersionMatching(`types-react-dom@rc`),
+        ]);
+        if (allDependencies['@types/react']) {
+            versionMapping['@types/react'] = {
+                version: `npm:types-react@${targetReactTypesVersion}`,
+                required: false,
+            };
+        }
+        if (allDependencies['@types/react-dom']) {
+            versionMapping['@types/react-dom'] = {
+                version: `npm:types-react-dom@${targetReactDOMTypesVersion}`,
+                required: false,
+            };
+        }
+    }
+    else {
+        const [targetReactTypesVersion, targetReactDOMTypesVersion] = await Promise.all([
+            loadHighestNPMVersionMatching(`@types/react@${targetNextPackageJson.peerDependencies['react']}`),
+            loadHighestNPMVersionMatching(`@types/react-dom@${targetNextPackageJson.peerDependencies['react']}`),
+        ]);
+        if (allDependencies['@types/react']) {
+            versionMapping['@types/react'] = {
+                version: targetReactTypesVersion,
+                required: false,
+            };
+        }
+        if (allDependencies['@types/react-dom']) {
+            versionMapping['@types/react-dom'] = {
+                version: targetReactDOMTypesVersion,
+                required: false,
+            };
+        }
+    }
+    // Even though we only need those if we alias `@types/react` to types-react,
+    // we still do it out of safety due to https://github.com/microsoft/DefinitelyTyped-tools/issues/433.
+    const overrides = {};
+    if (allDependencies['@types/react']) {
+        overrides['@types/react'] = versionMapping['@types/react'].version;
+    }
+    if (allDependencies['@types/react-dom']) {
+        overrides['@types/react-dom'] = versionMapping['@types/react-dom'].version;
+    }
+    writeOverridesField(appPackageJson, packageManager, overrides);
+    for (const [packageName, { version, required }] of Object.entries(versionMapping)) {
+        if (appPackageJson.devDependencies?.[packageName]) {
+            devDependenciesToInstall.push([packageName, version]);
+        }
+        else if (required || appPackageJson.dependencies?.[packageName]) {
+            dependenciesToInstall.push([packageName, version]);
+        }
+    }
+    console.log(`Upgrading your project to ${picocolors_1.default.blue('Next.js ' + targetNextVersion)}...\n`);
+    for (const [dep, version] of dependenciesToInstall) {
+        (0, handle_package_1.addPackageDependency)(appPackageJson, dep, version, false);
+    }
+    for (const [dep, version] of devDependenciesToInstall) {
+        (0, handle_package_1.addPackageDependency)(appPackageJson, dep, version, true);
+    }
+    fs_1.default.writeFileSync(appPackageJsonPath, JSON.stringify(appPackageJson, null, 2) +
+        // Common IDE formatters would add a newline as well.
+        os.EOL);
+    (0, handle_package_1.runInstallation)(packageManager);
+    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.`);
+    }
+    endMessage();
+}
+function getInstalledNextVersion() {
+    try {
+        return require(require.resolve('next/package.json', {
+            paths: [process.cwd()],
+        })).version;
+    }
+    catch (error) {
+        throw new shared_1.BadInput(`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 shared_1.BadInput(`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,
+        });
+    }
+}
+function isUsingPagesDir(projectPath) {
+    return (fs_1.default.existsSync(path_1.default.resolve(projectPath, 'pages')) ||
+        fs_1.default.existsSync(path_1.default.resolve(projectPath, 'src/pages')));
+}
+function isUsingAppDir(projectPath) {
+    return (fs_1.default.existsSync(path_1.default.resolve(projectPath, 'app')) ||
+        fs_1.default.existsSync(path_1.default.resolve(projectPath, 'src/app')));
+}
+/*
+ * 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) {
+    // example:
+    // codemod version: 15.0.0-canary.45
+    // 14.3             -> 15.0.0-canary.45: apply
+    // 14.3             -> 15.0.0-canary.44: don't apply
+    // 15.0.0-canary.44 -> 15.0.0-canary.45: apply
+    // 15.0.0-canary.45 -> 15.0.0-canary.46: don't apply
+    // 15.0.0-canary.45 -> 15.0.0          : don't apply
+    // 15.0.0-canary.44 -> 15.0.0          : apply
+    const initialVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((codemod) => {
+        return (0, compare_1.default)(codemod.version, initialNextVersion) > 0;
+    });
+    if (initialVersionIndex === -1) {
+        return [];
+    }
+    let targetVersionIndex = utils_1.TRANSFORMER_INQUIRER_CHOICES.findIndex((codemod) => (0, compare_1.default)(codemod.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: 'confirm',
+        name: 'runReactCodemod',
+        message: 'Would you like to run the React 19 upgrade codemod?',
+        initial: true,
+    }, { onCancel: utils_1.onCancel });
+    return runReactCodemod;
+}
+async function suggestReactTypesCodemods() {
+    const { runReactTypesCodemod } = await (0, prompts_1.default)({
+        type: 'confirm',
+        name: 'runReactTypesCodemod',
+        message: 'Would you like to run the React 19 Types upgrade codemod?',
+        initial: true,
+    }, { onCancel: utils_1.onCancel });
+    return runReactTypesCodemod;
+}
+function writeOverridesField(packageJson, packageManager, overrides) {
+    const entries = Object.entries(overrides);
+    // Avoids writing an empty overrides field into package.json
+    // which would be an unnecessary diff.
+    if (entries.length === 0) {
+        return;
+    }
+    if (packageManager === 'npm') {
+        if (!packageJson.overrides) {
+            packageJson.overrides = {};
+        }
+        for (const [key, value] of entries) {
+            packageJson.overrides[key] = value;
+        }
+    }
+    else if (packageManager === 'pnpm') {
+        // pnpm supports pnpm.overrides and pnpm.resolutions
+        if (packageJson.resolutions) {
+            for (const [key, value] of entries) {
+                packageJson.resolutions[key] = value;
+            }
+        }
+        else {
+            if (!packageJson.pnpm) {
+                packageJson.pnpm = {};
+            }
+            if (!packageJson.pnpm.overrides) {
+                packageJson.pnpm.overrides = {};
+            }
+            for (const [key, value] of entries) {
+                packageJson.pnpm.overrides[key] = value;
+            }
+        }
+    }
+    else if (packageManager === 'yarn') {
+        if (!packageJson.resolutions) {
+            packageJson.resolutions = {};
+        }
+        for (const [key, value] of entries) {
+            packageJson.resolutions[key] = value;
+        }
+    }
+    else if (packageManager === 'bun') {
+        // bun supports both overrides and resolutions
+        // x-ref: https://bun.sh/docs/install/overrides
+        if (packageJson.resolutions) {
+            for (const [key, value] of entries) {
+                packageJson.resolutions[key] = value;
+            }
+        }
+        else {
+            // add overrides field if it's missing and add overrides
+            if (!packageJson.overrides) {
+                packageJson.overrides = {};
+            }
+            for (const [key, value] of entries) {
+                packageJson.overrides[key] = value;
+            }
+        }
+    }
+}
+//# sourceMappingURL=upgrade.js.map