@next/codemod 15.0.0-canary.5 → 15.0.0-canary.50

package/bin/cli.js

@@ -126,6 +126,10 @@ const TRANSFORMER_INQUIRER_CHOICES = [
         name: 'metadata-to-viewport-export: Migrates certain viewport related metadata from the `metadata` export to a new `viewport` export.',
         value: 'metadata-to-viewport-export',
     },
+    {
+        name: 'next-dynamic-access-named-export: Transforms dynamic imports that return the named export itself to a module like object.',
+        value: 'next-dynamic-access-named-export',
+    },
     {
         name: 'next-image-to-legacy-image: safely migrate Next.js 10, 11, 12 applications importing `next/image` to the renamed `next/legacy/image` import in Next.js 13',
         value: 'next-image-to-legacy-image',

package/package.json

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

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function transformer(file, api) {
+    var _a, _b, _c;
+    const j = api.jscodeshift;
+    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 = (_c = (_b = (_a = importDecl.specifiers) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.local) === null || _c === void 0 ? void 0 : _c.name;
+        if (!dynamicImportName) {
+            return root.toSource();
+        }
+        // Find call expressions where the callee is the imported 'dynamic'
+        root
+            .find(j.CallExpression, {
+            callee: { name: dynamicImportName },
+        })
+            .forEach((path) => {
+            var _a;
+            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' &&
+                            ((_a = returnStatement.argument) === null || _a === void 0 ? void 0 : _a.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();
+}
+exports.default = transformer;
+//# sourceMappingURL=next-dynamic-access-named-export.js.map