@next/codemod 15.0.0-rc.0 → 15.0.0-rc.1

package/transforms/lib/async-request-api/utils.js

@@ -0,0 +1,374 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TARGET_PROP_NAMES = exports.TARGET_NAMED_EXPORTS = exports.TARGET_ROUTE_EXPORTS = exports.NEXT_CODEMOD_ERROR_PREFIX = exports.NEXTJS_ENTRY_FILES = void 0;
+exports.isFunctionType = isFunctionType;
+exports.isMatchedFunctionExported = isMatchedFunctionExported;
+exports.determineClientDirective = determineClientDirective;
+exports.isPromiseType = isPromiseType;
+exports.turnFunctionReturnTypeToAsync = turnFunctionReturnTypeToAsync;
+exports.insertReactUseImport = insertReactUseImport;
+exports.generateUniqueIdentifier = generateUniqueIdentifier;
+exports.isFunctionScope = isFunctionScope;
+exports.findClosetParentFunctionScope = findClosetParentFunctionScope;
+exports.getFunctionPathFromExportPath = getFunctionPathFromExportPath;
+exports.wrapParentheseIfNeeded = wrapParentheseIfNeeded;
+exports.insertCommentOnce = insertCommentOnce;
+exports.getVariableDeclaratorId = getVariableDeclaratorId;
+exports.NEXTJS_ENTRY_FILES = /([\\/]|^)(page|layout|route|default)\.(t|j)sx?$/;
+exports.NEXT_CODEMOD_ERROR_PREFIX = '@next-codemod-error';
+const NEXT_CODEMOD_IGNORE_ERROR_PREFIX = '@next-codemod-ignore';
+exports.TARGET_ROUTE_EXPORTS = new Set([
+    'GET',
+    'POST',
+    'PUT',
+    'PATCH',
+    'DELETE',
+    'OPTIONS',
+    'HEAD',
+]);
+exports.TARGET_NAMED_EXPORTS = new Set([
+    // For page and layout
+    'generateMetadata',
+    'generateViewport',
+    ...exports.TARGET_ROUTE_EXPORTS,
+]);
+exports.TARGET_PROP_NAMES = new Set(['params', 'searchParams']);
+function isFunctionType(type) {
+    return (type === 'FunctionDeclaration' ||
+        type === 'FunctionExpression' ||
+        type === 'ArrowFunctionExpression');
+}
+function isMatchedFunctionExported(path, j) {
+    const matchedFunctionNameFilter = (idName) => exports.TARGET_NAMED_EXPORTS.has(idName);
+    const directNamedExport = j(path).closest(j.ExportNamedDeclaration, {
+        declaration: {
+            type: 'FunctionDeclaration',
+            id: {
+                name: matchedFunctionNameFilter,
+            },
+        },
+    });
+    if (directNamedExport.size() > 0) {
+        return true;
+    }
+    // Check for default export (`export default function() {}`)
+    const isDefaultExport = j(path).closest(j.ExportDefaultDeclaration).size() > 0;
+    if (isDefaultExport) {
+        return true;
+    }
+    // Look for named export elsewhere in the file (`export { <named> }`)
+    const root = j(path).closestScope().closest(j.Program);
+    const isNamedExport = root
+        .find(j.ExportNamedDeclaration, {
+        specifiers: [
+            {
+                type: 'ExportSpecifier',
+                exported: {
+                    name: matchedFunctionNameFilter,
+                },
+            },
+        ],
+    })
+        .size() > 0;
+    // Look for variable export but still function, e.g. `export const <named> = function() {}`,
+    // also check if variable is a function or arrow function
+    const isVariableExport = root
+        .find(j.ExportNamedDeclaration, {
+        declaration: {
+            declarations: [
+                {
+                    type: 'VariableDeclarator',
+                    id: {
+                        type: 'Identifier',
+                        name: matchedFunctionNameFilter,
+                    },
+                    init: {
+                        type: isFunctionType,
+                    },
+                },
+            ],
+        },
+    })
+        .size() > 0;
+    if (isVariableExport)
+        return true;
+    return isNamedExport;
+}
+// directive is not parsed into AST, so we need to manually find it
+// by going through the tokens. Use the 1st string token as the directive
+function determineClientDirective(root, j) {
+    const { program } = root.get().node;
+    const directive = program.directives[0];
+    if (j.Directive.check(directive)) {
+        return directive.value.value === 'use client';
+    }
+    return false;
+}
+function isPromiseType(typeAnnotation) {
+    return (typeAnnotation.type === 'TSTypeReference' &&
+        typeAnnotation.typeName.name === 'Promise');
+}
+function turnFunctionReturnTypeToAsync(node, j) {
+    if (j.FunctionDeclaration.check(node) ||
+        j.FunctionExpression.check(node) ||
+        j.ArrowFunctionExpression.check(node)) {
+        if (node.returnType) {
+            const returnTypeAnnotation = node.returnType.typeAnnotation;
+            const isReturnTypePromise = isPromiseType(returnTypeAnnotation);
+            // Turn <return type> to Promise<return type>
+            // e.g. () => { slug: string } to () => Promise<{ slug: string }>
+            // e.g. Anything to Promise<Anything>
+            if (!isReturnTypePromise) {
+                if (node.returnType &&
+                    j.TSTypeAnnotation.check(node.returnType) &&
+                    (j.TSTypeReference.check(node.returnType.typeAnnotation) ||
+                        j.TSUnionType.check(node.returnType.typeAnnotation) ||
+                        j.TSTypePredicate.check(node.returnType.typeAnnotation))) {
+                    // Change the return type to Promise<void>
+                    node.returnType.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), 
+                    // @ts-ignore ignore the super strict type checking on the type annotation
+                    j.tsTypeParameterInstantiation([returnTypeAnnotation]));
+                }
+            }
+        }
+    }
+}
+function insertReactUseImport(root, j) {
+    const hasReactUseImport = root
+        .find(j.ImportSpecifier, {
+        imported: {
+            type: 'Identifier',
+            name: 'use',
+        },
+    })
+        .size() > 0;
+    if (!hasReactUseImport) {
+        const reactImportDeclaration = root.find(j.ImportDeclaration, {
+            source: {
+                value: 'react',
+            },
+            // Skip the type only react imports
+            importKind: 'value',
+        });
+        if (reactImportDeclaration.size() > 0) {
+            const importNode = reactImportDeclaration.get().node;
+            // Add 'use' to existing 'react' import declaration
+            importNode.specifiers.push(j.importSpecifier(j.identifier('use')));
+        }
+        else {
+            // Final all type imports to 'react'
+            if (reactImportDeclaration.size() > 0) {
+                reactImportDeclaration
+                    .get()
+                    .node.specifiers.push(j.importSpecifier(j.identifier('use')));
+            }
+            else {
+                // Add new import declaration for 'react' and 'use'
+                root
+                    .get()
+                    .node.program.body.unshift(j.importDeclaration([j.importSpecifier(j.identifier('use'))], j.literal('react')));
+            }
+        }
+    }
+}
+function findSubScopeArgumentIdentifier(path, j, argName) {
+    const defCount = j(path).find(j.Identifier, { name: argName }).size();
+    return defCount > 0;
+}
+function generateUniqueIdentifier(defaultIdName, path, j) {
+    let idName = defaultIdName;
+    let idNameSuffix = 0;
+    while (findSubScopeArgumentIdentifier(path, j, idName)) {
+        idName = defaultIdName + idNameSuffix;
+        idNameSuffix++;
+    }
+    const propsIdentifier = j.identifier(idName);
+    return propsIdentifier;
+}
+function isFunctionScope(path, j) {
+    if (!path)
+        return false;
+    const node = path.node;
+    // Check if the node is a function (declaration, expression, or arrow function)
+    return (j.FunctionDeclaration.check(node) ||
+        j.FunctionExpression.check(node) ||
+        j.ArrowFunctionExpression.check(node));
+}
+function findClosetParentFunctionScope(path, j) {
+    let parentFunctionPath = path.scope.path;
+    while (parentFunctionPath && !isFunctionScope(parentFunctionPath, j)) {
+        parentFunctionPath = parentFunctionPath.parent;
+    }
+    return parentFunctionPath;
+}
+function getFunctionNodeFromBinding(bindingPath, idName, j, root) {
+    const bindingNode = bindingPath.node;
+    if (j.FunctionDeclaration.check(bindingNode) ||
+        j.FunctionExpression.check(bindingNode) ||
+        j.ArrowFunctionExpression.check(bindingNode)) {
+        return bindingPath;
+    }
+    else if (j.VariableDeclarator.check(bindingNode)) {
+        const init = bindingNode.init;
+        // If the initializer is a function (arrow or function expression), record it
+        if (j.FunctionExpression.check(init) ||
+            j.ArrowFunctionExpression.check(init)) {
+            return bindingPath.get('init');
+        }
+    }
+    else if (j.Identifier.check(bindingNode)) {
+        const variablePath = root.find(j.VariableDeclaration, {
+            // declarations, each is VariableDeclarator
+            declarations: [
+                {
+                    // VariableDeclarator
+                    type: 'VariableDeclarator',
+                    // id is Identifier
+                    id: {
+                        type: 'Identifier',
+                        name: idName,
+                    },
+                },
+            ],
+        });
+        if (variablePath.size()) {
+            const variableDeclarator = variablePath.get()?.node?.declarations?.[0];
+            if (j.VariableDeclarator.check(variableDeclarator)) {
+                const init = variableDeclarator.init;
+                if (j.FunctionExpression.check(init) ||
+                    j.ArrowFunctionExpression.check(init)) {
+                    return variablePath.get('declarations', 0, 'init');
+                }
+            }
+        }
+        const functionDeclarations = root.find(j.FunctionDeclaration, {
+            id: {
+                name: idName,
+            },
+        });
+        if (functionDeclarations.size()) {
+            return functionDeclarations.get();
+        }
+    }
+    return undefined;
+}
+function getFunctionPathFromExportPath(exportPath, j, root, namedExportFilter) {
+    // Default export
+    if (j.ExportDefaultDeclaration.check(exportPath.node)) {
+        const { declaration } = exportPath.node;
+        if (declaration) {
+            if (j.FunctionDeclaration.check(declaration) ||
+                j.FunctionExpression.check(declaration) ||
+                j.ArrowFunctionExpression.check(declaration)) {
+                return exportPath.get('declaration');
+            }
+            else if (j.Identifier.check(declaration)) {
+                const idName = declaration.name;
+                if (!namedExportFilter(idName))
+                    return;
+                const exportBinding = exportPath.scope.getBindings()[idName]?.[0];
+                if (exportBinding) {
+                    return getFunctionNodeFromBinding(exportBinding, idName, j, root);
+                }
+            }
+        }
+    }
+    else if (
+    // Named exports
+    j.ExportNamedDeclaration.check(exportPath.node)) {
+        const namedExportPath = exportPath;
+        // extract the named exports, name specifiers, and default specifiers
+        const { declaration, specifiers } = namedExportPath.node;
+        if (declaration) {
+            if (j.VariableDeclaration.check(declaration)) {
+                const { declarations } = declaration;
+                for (const decl of declarations) {
+                    if (j.VariableDeclarator.check(decl) && j.Identifier.check(decl.id)) {
+                        const idName = decl.id.name;
+                        if (!namedExportFilter(idName))
+                            return;
+                        // get bindings for each variable declarator
+                        const exportBinding = namedExportPath.scope.getBindings()[idName]?.[0];
+                        if (exportBinding) {
+                            return getFunctionNodeFromBinding(exportBinding, idName, j, root);
+                        }
+                    }
+                }
+            }
+            else if (j.FunctionDeclaration.check(declaration) ||
+                j.FunctionExpression.check(declaration) ||
+                j.ArrowFunctionExpression.check(declaration)) {
+                const funcName = declaration.id?.name;
+                if (!namedExportFilter(funcName))
+                    return;
+                return namedExportPath.get('declaration');
+            }
+        }
+        if (specifiers) {
+            for (const specifier of specifiers) {
+                if (j.ExportSpecifier.check(specifier)) {
+                    const idName = specifier.local.name;
+                    if (!namedExportFilter(idName))
+                        return;
+                    const exportBinding = namedExportPath.scope.getBindings()[idName]?.[0];
+                    if (exportBinding) {
+                        return getFunctionNodeFromBinding(exportBinding, idName, j, root);
+                    }
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function wrapParentheseIfNeeded(hasChainAccess, j, expression) {
+    return hasChainAccess ? j.parenthesizedExpression(expression) : expression;
+}
+function existsComment(comments, comment) {
+    const isCodemodErrorComment = comment
+        .trim()
+        .startsWith(exports.NEXT_CODEMOD_ERROR_PREFIX);
+    let hasIgnoreComment = false;
+    let hasComment = false;
+    if (comments) {
+        comments.forEach((commentNode) => {
+            const currentComment = commentNode.value;
+            if (currentComment.trim().startsWith(NEXT_CODEMOD_IGNORE_ERROR_PREFIX)) {
+                hasIgnoreComment = true;
+            }
+            if (currentComment === comment) {
+                hasComment = true;
+            }
+        });
+        // If it's inserting codemod error comment,
+        // check if there's already a @next-codemod-ignore comment.
+        // if ignore comment exists, bypass the comment insertion.
+        if (hasIgnoreComment && isCodemodErrorComment) {
+            return true;
+        }
+        if (hasComment) {
+            return true;
+        }
+    }
+    return false;
+}
+function insertCommentOnce(node, j, comment) {
+    const hasCommentInInlineComments = existsComment(node.comments, comment);
+    const hasCommentInLeadingComments = existsComment(node.leadingComments, comment);
+    if (!hasCommentInInlineComments && !hasCommentInLeadingComments) {
+        // Always insert into inline comment
+        node.comments = [j.commentBlock(comment), ...(node.comments || [])];
+        return true;
+    }
+    return false;
+}
+function getVariableDeclaratorId(path, j) {
+    const parent = path.parentPath;
+    if (j.VariableDeclarator.check(parent.node)) {
+        const id = parent.node.id;
+        if (j.Identifier.check(id)) {
+            return id;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=utils.js.map

package/transforms/metadata-to-viewport-export.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function transformer(file, api) {
-    const j = api.jscodeshift;
+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 metadata export
     const metadataExport = root.find(j.ExportNamedDeclaration, {
@@ -56,5 +58,4 @@ function transformer(file, api) {
     }
     return root.toSource();
 }
-exports.default = transformer;
 //# sourceMappingURL=metadata-to-viewport-export.js.map

package/transforms/name-default-component.js

@@ -1,24 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
 const path_1 = require("path");
+const parser_1 = require("../lib/parser");
 const camelCase = (value) => {
     const val = value.replace(/[-_\s.]+(.)?/g, (_match, chr) => chr ? chr.toUpperCase() : '');
     return val.slice(0, 1).toUpperCase() + val.slice(1);
 };
 const isValidIdentifier = (value) => /^[a-zA-ZÀ-ÿ][0-9a-zA-ZÀ-ÿ]+$/.test(value);
-function transformer(file, api, options) {
-    const j = api.jscodeshift.withParser('tsx');
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
     let hasModifications;
     const returnsJSX = (node) => node.type === 'JSXElement' ||
         (node.type === 'BlockStatement' &&
             j(node)
                 .find(j.ReturnStatement)
-                .some((path) => { var _a; return ((_a = path.value.argument) === null || _a === void 0 ? void 0 : _a.type) === 'JSXElement'; }));
+                .some((path) => path.value.argument?.type === 'JSXElement'));
     const hasRootAsParent = (path) => {
-        var _a;
         const program = path.parentPath.parentPath.parentPath.parentPath.parentPath;
-        return !program || ((_a = program === null || program === void 0 ? void 0 : program.value) === null || _a === void 0 ? void 0 : _a.type) === 'Program';
+        return !program || program?.value?.type === 'Program';
     };
     const nameFunctionComponent = (path) => {
         const node = path.value;
@@ -62,5 +63,4 @@ function transformer(file, api, options) {
     root.find(j.ExportDefaultDeclaration).forEach(nameFunctionComponent);
     return hasModifications ? root.toSource(options) : null;
 }
-exports.default = transformer;
 //# sourceMappingURL=name-default-component.js.map

package/transforms/new-link.js

@@ -1,7 +1,11 @@
 "use strict";
+// It might insert extra parnes for JSX components
+// x-ref: https://github.com/facebook/jscodeshift/issues/534
 Object.defineProperty(exports, "__esModule", { value: true });
-function transformer(file, api) {
-    const j = api.jscodeshift.withParser('tsx');
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+function transformer(file, _api) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
     const $j = j(file.source);
     return $j
         .find(j.ImportDeclaration, { source: { value: 'next/link' } })
@@ -34,7 +38,7 @@ function transformer(file, api) {
                 return;
             }
             // If file has <style jsx> enable legacyBehavior
-            // and keep <a> to  stay on the safe side
+            // and keep <a> to stay on the safe side
             if (hasStylesJSX) {
                 $link
                     .get('attributes')
@@ -68,11 +72,10 @@ function transformer(file, api) {
                 // Add only unique props to <Link> (skip duplicate props)
                 const linkPropNames = $link
                     .get('attributes')
-                    .value.map((linkProp) => { var _a; return (_a = linkProp === null || linkProp === void 0 ? void 0 : linkProp.name) === null || _a === void 0 ? void 0 : _a.name; });
+                    .value.map((linkProp) => linkProp?.name?.name);
                 const uniqueProps = [];
                 props.forEach((anchorProp) => {
-                    var _a;
-                    if (!linkPropNames.includes((_a = anchorProp === null || anchorProp === void 0 ? void 0 : anchorProp.name) === null || _a === void 0 ? void 0 : _a.name)) {
+                    if (!linkPropNames.includes(anchorProp?.name?.name)) {
                         uniqueProps.push(anchorProp);
                     }
                 });
@@ -86,5 +89,4 @@ function transformer(file, api) {
     })
         .toSource();
 }
-exports.default = transformer;
 //# sourceMappingURL=new-link.js.map

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

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+var index_1 = require("./lib/async-request-api/index");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_1).default; } });
+//# sourceMappingURL=next-async-request-api.js.map

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

@@ -0,0 +1,66 @@
+"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

package/transforms/next-image-experimental.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
 const path_1 = require("path");
 const fs_1 = require("fs");
+const parser_1 = require("../lib/parser");
 function findAndReplaceProps(j, root, tagName) {
     const layoutToStyle = {
         intrinsic: { maxWidth: '100%', height: 'auto' },
@@ -21,14 +23,12 @@ function findAndReplaceProps(j, root, tagName) {
         el.value.openingElement.name.type === 'JSXIdentifier' &&
         el.value.openingElement.name.name === tagName)
         .forEach((el) => {
-        var _a;
         let layout = 'intrinsic';
         let objectFit = null;
         let objectPosition = null;
         let styleExpProps = [];
         let sizesAttr = null;
-        const attributes = (_a = el.node.openingElement.attributes) === null || _a === void 0 ? void 0 : _a.filter((a) => {
-            var _a, _b;
+        const attributes = el.node.openingElement.attributes?.filter((a) => {
             if (a.type !== 'JSXAttribute') {
                 return true;
             }
@@ -51,11 +51,11 @@ function findAndReplaceProps(j, root, tagName) {
                 return false;
             }
             if (a.name.name === 'style') {
-                if (((_a = a.value) === null || _a === void 0 ? void 0 : _a.type) === 'JSXExpressionContainer' &&
+                if (a.value?.type === 'JSXExpressionContainer' &&
                     a.value.expression.type === 'ObjectExpression') {
                     styleExpProps = a.value.expression.properties;
                 }
-                else if (((_b = a.value) === null || _b === void 0 ? void 0 : _b.type) === 'JSXExpressionContainer' &&
+                else if (a.value?.type === 'JSXExpressionContainer' &&
                     a.value.expression.type === 'Identifier') {
                     styleExpProps = [
                         j.spreadElement(j.identifier(a.value.expression.name)),
@@ -189,8 +189,8 @@ function nextConfigTransformer(j, root, appDir) {
     });
     return root;
 }
-function transformer(file, api, options) {
-    const j = api.jscodeshift.withParser('tsx');
+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' ||
@@ -208,9 +208,8 @@ function transformer(file, api, options) {
         source: { value: 'next/legacy/image' },
     })
         .forEach((imageImport) => {
-        var _a, _b;
-        const defaultSpecifier = (_a = imageImport.node.specifiers) === null || _a === void 0 ? void 0 : _a.find((node) => node.type === 'ImportDefaultSpecifier');
-        const tagName = (_b = defaultSpecifier === null || defaultSpecifier === void 0 ? void 0 : defaultSpecifier.local) === null || _b === void 0 ? void 0 : _b.name;
+        const defaultSpecifier = imageImport.node.specifiers?.find((node) => node.type === 'ImportDefaultSpecifier');
+        const tagName = defaultSpecifier?.local?.name;
         imageImport.node.source = j.stringLiteral('next/image');
         if (tagName) {
             findAndReplaceProps(j, root, tagName);
@@ -220,7 +219,7 @@ function transformer(file, api, options) {
     //  After: const Image = await import("next/image")
     root.find(j.AwaitExpression).forEach((awaitExp) => {
         const arg = awaitExp.value.argument;
-        if ((arg === null || arg === void 0 ? void 0 : arg.type) === 'CallExpression' && arg.callee.type === 'Import') {
+        if (arg?.type === 'CallExpression' && arg.callee.type === 'Import') {
             if (arg.arguments[0].type === 'StringLiteral' &&
                 arg.arguments[0].value === 'next/legacy/image') {
                 arg.arguments[0] = j.stringLiteral('next/image');
@@ -230,14 +229,13 @@ function transformer(file, api, options) {
     // Before: const Image = require("next/legacy/image")
     //  After: const Image = require("next/image")
     root.find(j.CallExpression).forEach((requireExp) => {
-        var _a, _b, _c, _d, _e;
-        if (((_b = (_a = requireExp === null || requireExp === void 0 ? void 0 : requireExp.value) === null || _a === void 0 ? void 0 : _a.callee) === null || _b === void 0 ? void 0 : _b.type) === 'Identifier' &&
+        if (requireExp?.value?.callee?.type === 'Identifier' &&
             requireExp.value.callee.name === 'require') {
             let firstArg = requireExp.value.arguments[0];
             if (firstArg &&
                 firstArg.type === 'StringLiteral' &&
                 firstArg.value === 'next/legacy/image') {
-                const tagName = (_e = (_d = (_c = requireExp === null || requireExp === void 0 ? void 0 : requireExp.parentPath) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.id) === null || _e === void 0 ? void 0 : _e.name;
+                const tagName = requireExp?.parentPath?.value?.id?.name;
                 if (tagName) {
                     requireExp.value.arguments[0] = j.stringLiteral('next/image');
                     findAndReplaceProps(j, root, tagName);
@@ -248,5 +246,4 @@ function transformer(file, api, options) {
     // TODO: do the same transforms for dynamic imports
     return root.toSource(options);
 }
-exports.default = transformer;
 //# sourceMappingURL=next-image-experimental.js.map