@next/codemod 16.0.0-canary.8 → 16.0.0

package/bin/upgrade.js

@@ -164,7 +164,8 @@ async function runUpgrade(revision, options) {
     const targetReactVersion = shouldStayOnReact18
         ? '18.3.1'
         : await loadHighestNPMVersionMatching(`react@${targetNextPackageJson.peerDependencies['react']}`);
-    if ((0, semver_1.compare)(targetNextVersion, '15.0.0-canary') >= 0) {
+    if ((0, semver_1.compare)(targetNextVersion, '15.0.0-canary') >= 0 &&
+        (0, semver_1.compare)(targetNextVersion, '16.0.0-canary') < 0) {
         await suggestTurbopack(appPackageJson, targetNextVersion);
     }
     const codemods = await suggestCodemods(installedNextVersion, targetNextVersion);

package/lib/utils.js

@@ -122,5 +122,15 @@ exports.TRANSFORMER_INQUIRER_CHOICES = [
         value: 'middleware-to-proxy',
         version: '15.6.0-canary.54',
     },
+    {
+        title: 'Remove `unstable_` prefix from stabilized API',
+        value: 'remove-unstable-prefix',
+        version: '16.0.0-canary.10',
+    },
+    {
+        title: 'Remove `experimental_ppr` Route Segment Config from App Router pages and layouts',
+        value: 'remove-experimental-ppr',
+        version: '16.0.0-canary.11',
+    },
 ];
 //# sourceMappingURL=utils.js.map

package/package.json

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

package/transforms/middleware-to-proxy.js

@@ -45,6 +45,9 @@ function transformer(file) {
     if (isMiddlewareFile) {
         const middlewareChanges = transformMiddlewareFunction(root, j);
         hasChanges = hasChanges || middlewareChanges.hasChanges;
+        // Remove runtime segment config
+        const runtimeChanges = removeRuntimeConfig(root, j);
+        hasChanges = hasChanges || runtimeChanges;
     }
     if (isNextConfig) {
         const { hasConfigChanges } = transformNextConfig(root, j);
@@ -602,4 +605,123 @@ function extractObjectsFromCallExpression(callExpr, configObjects, exportedNames
         });
     }
 }
+function removeRuntimeConfig(root, j) {
+    let hasChanges = false;
+    // Remove export const runtime = 'string'
+    const directRuntimeExports = root.find(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'VariableDeclaration',
+            declarations: [
+                {
+                    id: { name: 'runtime' },
+                },
+            ],
+        },
+    });
+    if (directRuntimeExports.size() > 0) {
+        directRuntimeExports.remove();
+        hasChanges = true;
+    }
+    // Remove const runtime = 'string' declarations
+    const runtimeVariableDeclarations = root
+        .find(j.VariableDeclaration)
+        .filter((path) => path.node.declarations.some((decl) => {
+        if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
+            return decl.id.name === 'runtime';
+        }
+        return false;
+    }));
+    if (runtimeVariableDeclarations.size() > 0) {
+        runtimeVariableDeclarations.forEach((path) => {
+            const originalDeclarations = path.node.declarations;
+            const filteredDeclarations = originalDeclarations.filter((decl) => {
+                if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
+                    return decl.id.name !== 'runtime';
+                }
+                return true;
+            });
+            // If we filtered out some declarations, update the node
+            if (filteredDeclarations.length !== originalDeclarations.length) {
+                // Remove the entire declaration only if no declarators left
+                if (filteredDeclarations.length === 0) {
+                    j(path).remove();
+                }
+                else {
+                    path.node.declarations = filteredDeclarations;
+                }
+            }
+        });
+        hasChanges = true;
+    }
+    // Handle export { runtime } and export { runtime, other }
+    const namedExports = root
+        .find(j.ExportNamedDeclaration)
+        .filter((path) => path.node.specifiers && path.node.specifiers.length > 0);
+    namedExports.forEach((path) => {
+        const specifiers = path.node.specifiers;
+        if (!specifiers)
+            return;
+        const filteredSpecifiers = specifiers.filter((spec) => {
+            if (j.ExportSpecifier.check(spec) && j.Identifier.check(spec.local)) {
+                return spec.local.name !== 'runtime';
+            }
+            return true;
+        });
+        // If we removed any specifiers
+        if (filteredSpecifiers.length !== specifiers.length) {
+            hasChanges = true;
+            // If no specifiers left, remove the entire export statement
+            if (filteredSpecifiers.length === 0) {
+                j(path).remove();
+            }
+            else {
+                // Update the specifiers array
+                path.node.specifiers = filteredSpecifiers;
+            }
+        }
+    });
+    // Handle runtime property in config objects
+    const configExports = root.find(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'VariableDeclaration',
+            declarations: [
+                {
+                    id: { name: 'config' },
+                },
+            ],
+        },
+    });
+    configExports.forEach((path) => {
+        const declaration = path.node.declaration;
+        if (j.VariableDeclaration.check(declaration)) {
+            declaration.declarations.forEach((decl) => {
+                if (j.VariableDeclarator.check(decl) &&
+                    j.Identifier.check(decl.id) &&
+                    decl.id.name === 'config' &&
+                    j.ObjectExpression.check(decl.init)) {
+                    const objExpr = decl.init;
+                    const initialLength = objExpr.properties.length;
+                    // Filter out runtime property
+                    objExpr.properties = objExpr.properties.filter((prop) => {
+                        if (isStaticProperty(prop) &&
+                            prop.key &&
+                            prop.key.type === 'Identifier') {
+                            return prop.key.name !== 'runtime';
+                        }
+                        return true;
+                    });
+                    // If we removed any properties
+                    if (objExpr.properties.length !== initialLength) {
+                        hasChanges = true;
+                        // If no properties left, remove the entire config export
+                        if (objExpr.properties.length === 0) {
+                            j(path).remove();
+                        }
+                    }
+                }
+            });
+        }
+    });
+    return hasChanges;
+}
 //# sourceMappingURL=middleware-to-proxy.js.map