@next/codemod 15.4.2-canary.3 → 15.4.2-canary.30

package/README.md

@@ -6,4 +6,4 @@ Codemods are transformations that run on your codebase programmatically. This al
 
 ## Documentation
 
-Visit [nextjs.org/docs/advanced-features/codemods](https://nextjs.org/docs/advanced-features/codemods) to view the documentation for this package.
+Visit [nextjs.org/docs/advanced-features/codemods](https://nextjs.org/docs/app/guides/upgrading/codemods) to view the documentation for this package.

package/bin/transform.js

@@ -92,7 +92,7 @@ async function runTransform(transform, path, options) {
     if (verbose) {
         args.push('--verbose=2');
     }
-    args.push('--no-babel');
+    args.push('--parser=tsx');
     args.push('--ignore-pattern=**/node_modules/**');
     args.push('--ignore-pattern=**/.next/**');
     args.push('--extensions=tsx,ts,jsx,js');

package/lib/utils.js

@@ -106,5 +106,10 @@ exports.TRANSFORMER_INQUIRER_CHOICES = [
         value: 'app-dir-runtime-config-experimental-edge',
         version: '15.0.0-canary.179',
     },
+    {
+        title: 'Updates `next.config.js` to use the new `turbopack` configuration',
+        value: 'next-experimental-turbo-to-turbopack',
+        version: '10.0.0',
+    },
 ];
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "15.4.2-canary.3",
+  "version": "15.4.2-canary.30",
   "license": "MIT",
   "repository": {
     "type": "git",

package/transforms/lib/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNextConfigFile = isNextConfigFile;
+const node_path_1 = __importDefault(require("node:path"));
+function isNextConfigFile(file) {
+    const parsed = node_path_1.default.parse(file.path || '/');
+    return (parsed.base === 'next.config.js' ||
+        parsed.base === 'next.config.ts' ||
+        parsed.base === 'next.config.mjs' ||
+        parsed.base === 'next.config.cjs');
+}
+//# sourceMappingURL=utils.js.map

package/transforms/next-experimental-turbo-to-turbopack.js

@@ -0,0 +1,204 @@
+"use strict";
+/*
+ * This codemod transforms the experimental turbo configuration in Next.js config to
+ * the new top-level `turbopack` configuration.
+ *
+ * It moves most properties from experimental.turbo to the top-level turbopack
+ * property, with special handling for certain properties like memoryLimit, minify,
+ * treeShaking, and sourceMaps which become experimental.turbopack* properties instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+const utils_1 = require("./lib/utils");
+// Properties that need to be moved to experimental.turbopack*
+const RENAMED_EXPERIMENTAL_PROPERTIES = {
+    memoryLimit: 'turbopackMemoryLimit',
+    minify: 'turbopackMinify',
+    treeShaking: 'turbopackTreeShaking',
+    sourceMaps: 'turbopackSourceMaps',
+};
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
+    const root = j(file.source);
+    let hasChanges = false;
+    if (!(0, utils_1.isNextConfigFile)(file) &&
+        process.env.NODE_ENV !== 'test' // fixtures have unique basenames in test
+    ) {
+        return file.source;
+    }
+    // Process a config object once we find it
+    function processConfigObject(configObj) {
+        // Check for `experimental` property in the config
+        const experimentalProp = configObj.properties.find((prop) => isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'experimental');
+        if (!experimentalProp || !isStaticProperty(experimentalProp)) {
+            return false;
+        }
+        const experimentalObj = experimentalProp.value;
+        if (experimentalObj.type !== 'ObjectExpression') {
+            return false;
+        }
+        // Check for `experimental.turbo` property in the config
+        const turboProp = experimentalObj.properties.find((prop) => isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'turbo');
+        if (!turboProp || !isStaticProperty(turboProp)) {
+            return false;
+        }
+        const turboObj = turboProp.value;
+        if (turboObj.type !== 'ObjectExpression') {
+            return false;
+        }
+        const regularProps = [];
+        const specialProps = [];
+        turboObj.properties.forEach((prop) => {
+            if (isStaticProperty(prop) &&
+                prop.key &&
+                prop.key.type === 'Identifier' &&
+                RENAMED_EXPERIMENTAL_PROPERTIES[prop.key.name]) {
+                // Create a new property with the renamed key
+                specialProps.push(j.objectProperty(j.identifier(RENAMED_EXPERIMENTAL_PROPERTIES[prop.key.name]), prop.value));
+            }
+            else {
+                // Keep the property for turbopack
+                regularProps.push(prop);
+            }
+        });
+        const existingProps = experimentalObj.properties.filter((prop) => !(isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'turbo'));
+        experimentalObj.properties = [...existingProps, ...specialProps];
+        // If experimental has no properties, remove it
+        if (experimentalObj.properties.length === 0) {
+            configObj.properties = configObj.properties.filter((prop) => !(isStaticProperty(prop) &&
+                prop.key &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === 'experimental'));
+        }
+        // Add turbopack property at top level if there are regular props
+        if (regularProps.length > 0) {
+            // Create the turbopack property
+            const turbopackProp = j.objectProperty(j.identifier('turbopack'), j.objectExpression(regularProps));
+            configObj.properties.push(turbopackProp);
+        }
+        return true;
+    }
+    root.find(j.ObjectExpression).forEach((path) => {
+        if (processConfigObject(path.value)) {
+            hasChanges = true;
+        }
+    });
+    // Transform config.experimental.turbo.X = value to config.turbopack.X = value
+    // or config.experimental.turbopackX = value for special properties
+    root
+        .find(j.AssignmentExpression, {
+        left: {
+            type: 'MemberExpression',
+            object: {
+                type: 'MemberExpression',
+                object: {
+                    type: 'MemberExpression',
+                    property: { type: 'Identifier', name: 'experimental' },
+                },
+                property: { type: 'Identifier', name: 'turbo' },
+            },
+        },
+    })
+        .forEach((path) => {
+        if (path.node.left.type !== 'MemberExpression')
+            return;
+        // Get the variable name (e.g., config in config.experimental.turbo.sourceMaps)
+        let varName = null;
+        let currentPath = path.node.left.object;
+        while (currentPath?.type === 'MemberExpression') {
+            currentPath = currentPath.object;
+        }
+        if (currentPath?.type === 'Identifier') {
+            varName = currentPath.name;
+        }
+        if (!varName)
+            return;
+        // Get the property name being assigned (e.g., sourceMaps)
+        let propName = undefined;
+        if (path.node.left.property &&
+            path.node.left.property.type === 'Identifier') {
+            propName = path.node.left.property.name;
+        }
+        else {
+            return;
+        }
+        // For special properties like memoryLimit, minify, etc.
+        if (propName && RENAMED_EXPERIMENTAL_PROPERTIES[propName]) {
+            const newAssignment = j.assignmentExpression('=', j.memberExpression(j.memberExpression(j.identifier(varName), j.identifier('experimental')), j.identifier(RENAMED_EXPERIMENTAL_PROPERTIES[propName])), path.node.right);
+            j(path).replaceWith(newAssignment);
+            hasChanges = true;
+        }
+        else if (propName) {
+            // Create new assignment: config.turbopack.propName = value
+            const newAssignment = j.assignmentExpression('=', j.memberExpression(j.memberExpression(j.identifier(varName), j.identifier('turbopack')), j.identifier(propName)), path.node.right);
+            j(path).replaceWith(newAssignment);
+            hasChanges = true;
+        }
+    });
+    // For nested property assignments like config.experimental.turbo.resolveAlias.foo = 'bar';
+    root.find(j.AssignmentExpression).forEach((path) => {
+        if (path.node.left.type !== 'MemberExpression')
+            return;
+        // Build a path to check if this is like `experimental.turbo.resolveAlias.foo`
+        let obj = path.node.left.object;
+        let props = [];
+        // Collect the property chain
+        while (obj && obj.type === 'MemberExpression') {
+            if (obj.property && obj.property.type === 'Identifier') {
+                props.unshift(obj.property.name);
+            }
+            obj = obj.object;
+        }
+        // Get the root variable name (e.g., 'config')
+        let varName = null;
+        if (obj && obj.type === 'Identifier') {
+            varName = obj.name;
+        }
+        if (!varName)
+            return;
+        // Check if this matches the pattern: config.experimental.turbo.resolveAlias.foo
+        if (props.length >= 3 &&
+            props[0] === 'experimental' &&
+            props[1] === 'turbo') {
+            // Get the final property name, only if it's an Identifier
+            let finalProp = undefined;
+            if (path.node.left.property &&
+                path.node.left.property.type === 'Identifier') {
+                finalProp = path.node.left.property.name;
+            }
+            else {
+                // If not an Identifier, skip this assignment
+                return;
+            }
+            // The properties after 'turbo'
+            const middleProps = props.slice(2); // e.g. ['resolveAlias']
+            // Start building the new left side: config.turbopack
+            let newLeft = j.memberExpression(j.identifier(varName), j.identifier('turbopack'));
+            // Add the middle properties
+            for (const prop of middleProps) {
+                newLeft = j.memberExpression(newLeft, j.identifier(prop));
+            }
+            // Add the final property
+            newLeft = j.memberExpression(newLeft, j.identifier(finalProp));
+            const newAssignment = j.assignmentExpression('=', newLeft, path.node.right);
+            j(path).replaceWith(newAssignment);
+            hasChanges = true;
+        }
+    });
+    // Only return a string if we changed the AST, otherwise return the original source
+    return hasChanges ? root.toSource(options) : file.source;
+}
+function isStaticProperty(prop) {
+    return prop.type === 'Property' || prop.type === 'ObjectProperty';
+}
+//# sourceMappingURL=next-experimental-turbo-to-turbopack.js.map

package/transforms/next-image-experimental.js

@@ -4,6 +4,7 @@ exports.default = transformer;
 const path_1 = require("path");
 const fs_1 = require("fs");
 const parser_1 = require("../lib/parser");
+const utils_1 = require("./lib/utils");
 function findAndReplaceProps(j, root, tagName) {
     const layoutToStyle = {
         intrinsic: { maxWidth: '100%', height: 'auto' },
@@ -192,14 +193,11 @@ function nextConfigTransformer(j, root, appDir) {
 function transformer(file, _api, options) {
     const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
-    const parsed = (0, path_1.parse)(file.path || '/');
-    const isConfig = parsed.base === 'next.config.js' ||
-        parsed.base === 'next.config.ts' ||
-        parsed.base === 'next.config.mjs' ||
-        parsed.base === 'next.config.cjs';
+    const isConfig = (0, utils_1.isNextConfigFile)(file);
     if (isConfig) {
-        const result = nextConfigTransformer(j, root, parsed.dir);
-        return result.toSource();
+        const fileDir = (0, path_1.parse)(file.path).dir;
+        const result = nextConfigTransformer(j, root, fileDir);
+        return result.toSource(options);
     }
     // Before: import Image from "next/legacy/image"
     //  After: import Image from "next/image"