@next/codemod 15.0.2-canary.9 → 15.0.2

package/lib/utils.js

@@ -91,11 +91,6 @@ exports.TRANSFORMER_INQUIRER_CHOICES = [
         value: 'next-og-import',
         version: '14.0.0',
     },
-    {
-        title: 'Transform `next/dynamic` imports accessing named exports to return an object with a `default` property',
-        value: 'next-dynamic-access-named-export',
-        version: '15.0.0-canary.44',
-    },
     {
         title: 'Install `@vercel/functions` to replace `geo` and `ip` properties on `NextRequest`',
         value: 'next-request-geo-ip',

package/package.json

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

package/transforms/lib/async-request-api/next-async-dynamic-api.js

@@ -230,7 +230,23 @@ function castTypesOrAddComment(j, path, originRequestApiName, root, filePath, in
         const newCastExpression = j.tsAsExpression(j.tsAsExpression(path.node, j.tsUnknownKeyword()), j.tsTypeReference(j.identifier(targetType)));
         // Replace the original expression with the new cast expression,
         // also wrap () around the new cast expression.
-        j(path).replaceWith(j.parenthesizedExpression(newCastExpression));
+        const parent = path.parent.value;
+        const wrappedExpression = j.parenthesizedExpression(newCastExpression);
+        path.replace(wrappedExpression);
+        // If the wrapped expression `(<expression>)` is the beginning of an expression statement,
+        // add a void operator to separate the statement, to avoid syntax error that being treated as part of previous statement.
+        // example:
+        // input:
+        // <expression>
+        // <expression>
+        // output:
+        // (<expression> as ...)
+        // void (<expression> as ...)
+        if (j.ExpressionStatement.check(parent) &&
+            parent.expression === path.node) {
+            // append a semicolon to the start of the expression statement
+            parent.expression = j.unaryExpression('void', parent.expression);
+        }
         modified = true;
         // If cast types are not imported, add them to the import list
         const importDeclaration = root.find(j.ImportDeclaration, {

package/transforms/next-dynamic-access-named-export.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = transformer;
-const parser_1 = require("../lib/parser");
-function transformer(file, _api) {
-    const j = (0, parser_1.createParserFromPath)(file.path);
-    const root = j(file.source);
-    // Find the import declaration for 'next/dynamic'
-    const dynamicImportDeclaration = root.find(j.ImportDeclaration, {
-        source: { value: 'next/dynamic' },
-    });
-    // If the import declaration is found
-    if (dynamicImportDeclaration.size() > 0) {
-        const importDecl = dynamicImportDeclaration.get(0).node;
-        const dynamicImportName = importDecl.specifiers?.[0]?.local?.name;
-        if (!dynamicImportName) {
-            return file.source;
-        }
-        // Find call expressions where the callee is the imported 'dynamic'
-        root
-            .find(j.CallExpression, {
-            callee: { name: dynamicImportName },
-        })
-            .forEach((path) => {
-            const arrowFunction = path.node.arguments[0];
-            // Ensure the argument is an ArrowFunctionExpression
-            if (arrowFunction && arrowFunction.type === 'ArrowFunctionExpression') {
-                const importCall = arrowFunction.body;
-                // Ensure the parent of the import call is a CallExpression with a .then
-                if (importCall &&
-                    importCall.type === 'CallExpression' &&
-                    importCall.callee.type === 'MemberExpression' &&
-                    'name' in importCall.callee.property &&
-                    importCall.callee.property.name === 'then') {
-                    const thenFunction = importCall.arguments[0];
-                    // handle case of block statement case `=> { return mod.Component }`
-                    // transform to`=> { return { default: mod.Component } }`
-                    if (thenFunction &&
-                        thenFunction.type === 'ArrowFunctionExpression' &&
-                        thenFunction.body.type === 'BlockStatement') {
-                        const returnStatement = thenFunction.body.body[0];
-                        // Ensure the body of the arrow function has a return statement with a MemberExpression
-                        if (returnStatement &&
-                            returnStatement.type === 'ReturnStatement' &&
-                            returnStatement.argument?.type === 'MemberExpression') {
-                            returnStatement.argument = j.objectExpression([
-                                j.property('init', j.identifier('default'), returnStatement.argument),
-                            ]);
-                        }
-                    }
-                    // handle case `=> mod.Component`
-                    // transform to`=> ({ default: mod.Component })`
-                    if (thenFunction &&
-                        thenFunction.type === 'ArrowFunctionExpression' &&
-                        thenFunction.body.type === 'MemberExpression') {
-                        thenFunction.body = j.objectExpression([
-                            j.property('init', j.identifier('default'), thenFunction.body),
-                        ]);
-                    }
-                }
-            }
-        });
-    }
-    return root.toSource();
-}
-//# sourceMappingURL=next-dynamic-access-named-export.js.map