@next/codemod 15.0.0-canary.174 → 15.0.0-canary.176

package/bin/next-codemod.js

@@ -30,7 +30,11 @@ const program = new commander_1.Command(packageJson.name)
 program
     .command('upgrade')
     .description('Upgrade Next.js apps to desired versions with a single command.')
-    .argument('[revision]', 'NPM dist tag or exact version to upgrade to (e.g. "latest" or "15.0.0-canary.167"). Prompts to choose a dist tag if omitted.')
+    .argument('[revision]', 'NPM dist tag or exact version to upgrade to (e.g. "latest" or "15.0.0-canary.167"). Valid dist-tags are "latest", "canary" or "rc".', packageJson.version.includes('-canary.')
+    ? 'canary'
+    : packageJson.version.includes('-rc.')
+        ? 'rc'
+        : 'latest')
     .option('--verbose', 'Verbose output', false)
     .action(upgrade_1.runUpgrade);
 program.parse(process.argv);

package/bin/upgrade.js

@@ -31,70 +31,14 @@ async function runUpgrade(revision, options) {
     let appPackageJson = JSON.parse(fs_1.default.readFileSync(appPackageJsonPath, 'utf8'));
     await detectWorkspace(appPackageJson);
     let targetNextPackageJson;
-    let targetVersionSpecifier = '';
-    if (revision !== undefined) {
-        const res = await fetch(`https://registry.npmjs.org/next/${revision}`);
-        if (res.status === 200) {
-            targetNextPackageJson = await res.json();
-            targetVersionSpecifier = targetNextPackageJson.version;
-        }
-        else {
-            console.error(`${chalk_1.default.yellow(`next@${revision}`)} does not exist. Check available versions at ${chalk_1.default.underline('https://www.npmjs.com/package/next?activeTab=versions')}, or choose one from below\n`);
-        }
+    const res = await fetch(`https://registry.npmjs.org/next/${revision}`);
+    if (res.status === 200) {
+        targetNextPackageJson = await res.json();
     }
-    const installedNextVersion = await getInstalledNextVersion();
-    if (!targetNextPackageJson) {
-        let nextPackageJson = {};
-        try {
-            const resCanary = await fetch(`https://registry.npmjs.org/next/canary`);
-            nextPackageJson['canary'] = await resCanary.json();
-            const resRc = await fetch(`https://registry.npmjs.org/next/rc`);
-            nextPackageJson['rc'] = await resRc.json();
-            const resLatest = await fetch(`https://registry.npmjs.org/next/latest`);
-            nextPackageJson['latest'] = await resLatest.json();
-        }
-        catch (error) {
-            console.error('Failed to fetch versions from npm registry.');
-            return;
-        }
-        let showRc = true;
-        if (nextPackageJson['latest'].version && nextPackageJson['rc'].version) {
-            showRc =
-                (0, compare_versions_1.compareVersions)(nextPackageJson['rc'].version, nextPackageJson['latest'].version) === 1;
-        }
-        const choices = [
-            {
-                title: 'Canary',
-                value: 'canary',
-                description: `Experimental version with latest features (${nextPackageJson['canary'].version})`,
-            },
-        ];
-        if (showRc) {
-            choices.push({
-                title: 'Release Candidate',
-                value: 'rc',
-                description: `Pre-release version for final testing (${nextPackageJson['rc'].version})`,
-            });
-        }
-        choices.push({
-            title: 'Stable',
-            value: 'latest',
-            description: `Production-ready release (${nextPackageJson['latest'].version})`,
-        });
-        if (installedNextVersion) {
-            console.log(`You are currently using ${chalk_1.default.blue('Next.js ' + installedNextVersion)}`);
-        }
-        const initialVersionSpecifierIdx = await getVersionSpecifierIdx(installedNextVersion, showRc);
-        const response = await (0, prompts_1.default)({
-            type: 'select',
-            name: 'version',
-            message: 'What Next.js version do you want to upgrade to?',
-            choices: choices,
-            initial: initialVersionSpecifierIdx,
-        }, { onCancel: () => process.exit(0) });
-        targetNextPackageJson = nextPackageJson[response.version];
-        targetVersionSpecifier = response.version;
+    else {
+        throw new Error(`${chalk_1.default.yellow(`next@${revision}`)} does not exist. Check available versions at ${chalk_1.default.underline('https://www.npmjs.com/package/next?activeTab=versions')}.`);
     }
+    const installedNextVersion = await getInstalledNextVersion();
     const targetNextVersion = targetNextPackageJson.version;
     // We're resolving a specific version here to avoid including "ugly" version queries
     // in the manifest.
@@ -109,6 +53,7 @@ async function runUpgrade(revision, options) {
     if ((0, compare_versions_1.compareVersions)(targetNextVersion, '15.0.0-canary') >= 0) {
         await suggestTurbopack(appPackageJson);
     }
+    const codemods = await suggestCodemods(installedNextVersion, targetNextVersion);
     fs_1.default.writeFileSync(appPackageJsonPath, JSON.stringify(appPackageJson, null, 2));
     const packageManager = (0, handle_package_1.getPkgManager)(process.cwd());
     const nextDependency = `next@${targetNextVersion}`;
@@ -126,12 +71,14 @@ async function runUpgrade(revision, options) {
         reactDependencies.push(`@types/react@${targetReactTypesVersion}`);
         reactDependencies.push(`@types/react-dom@${targetReactDOMTypesVersion}`);
     }
-    console.log(`Upgrading your project to ${chalk_1.default.blue('Next.js ' + targetVersionSpecifier)}...\n`);
+    console.log(`Upgrading your project to ${chalk_1.default.blue('Next.js ' + targetNextVersion)}...\n`);
     (0, handle_package_1.installPackages)([nextDependency, ...reactDependencies], {
         packageManager,
         silent: !verbose,
     });
-    await suggestCodemods(installedNextVersion, targetNextVersion);
+    for (const codemod of codemods) {
+        await (0, transform_1.runTransform)(codemod, process.cwd(), { force: true });
+    }
     console.log(`\n${chalk_1.default.green('✔')} Your Next.js project has been upgraded successfully. ${chalk_1.default.bold('Time to ship! 🚢')}`);
 }
 async function detectWorkspace(appPackageJson) {
@@ -157,22 +104,6 @@ async function getInstalledNextVersion() {
     const installedNextPackageJson = JSON.parse(fs_1.default.readFileSync(installedNextPackageJsonDir, 'utf8'));
     return installedNextPackageJson.version;
 }
-/*
- * Returns the index of the current version's specifier in the
- * array ['canary', 'rc', 'latest'] or ['canary', 'latest']
- */
-async function getVersionSpecifierIdx(installedNextVersion, showRc) {
-    if (installedNextVersion == null) {
-        return 0;
-    }
-    if (installedNextVersion.includes('canary')) {
-        return 0;
-    }
-    if (installedNextVersion.includes('rc')) {
-        return 1;
-    }
-    return showRc ? 2 : 1;
-}
 /*
  * Heuristics are used to determine whether to Turbopack is enabled or not and
  * to determine how to update the dev script.
@@ -217,7 +148,7 @@ async function suggestTurbopack(packageJson) {
 async function suggestCodemods(initialNextVersion, targetNextVersion) {
     const initialVersionIndex = codemods_1.availableCodemods.findIndex((versionCodemods) => (0, compare_versions_1.compareVersions)(versionCodemods.version, initialNextVersion) > 0);
     if (initialVersionIndex === -1) {
-        return;
+        return [];
     }
     let targetVersionIndex = codemods_1.availableCodemods.findIndex((versionCodemods) => (0, compare_versions_1.compareVersions)(versionCodemods.version, targetNextVersion) > 0);
     if (targetVersionIndex === -1) {
@@ -227,7 +158,7 @@ async function suggestCodemods(initialNextVersion, targetNextVersion) {
         .slice(initialVersionIndex, targetVersionIndex)
         .flatMap((versionCodemods) => versionCodemods.codemods);
     if (relevantCodemods.length === 0) {
-        return;
+        return [];
     }
     const { codemods } = await (0, prompts_1.default)({
         type: 'multiselect',
@@ -245,8 +176,6 @@ async function suggestCodemods(initialNextVersion, targetNextVersion) {
             process.exit(0);
         },
     });
-    for (const codemod of codemods) {
-        await (0, transform_1.runTransform)(codemod, process.cwd(), { force: true });
-    }
+    return codemods;
 }
 //# sourceMappingURL=upgrade.js.map

package/package.json

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

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

@@ -17,7 +17,7 @@ function findDynamicImportsAndComment(root, j) {
         arguments: [{ value: 'next/headers' }],
     });
     importPaths.forEach((path) => {
-        (0, utils_1.insertCommentOnce)(path, j, DYNAMIC_IMPORT_WARN_COMMENT);
+        (0, utils_1.insertCommentOnce)(path.node, j, DYNAMIC_IMPORT_WARN_COMMENT);
         modified = true;
     });
     return modified;
@@ -145,7 +145,7 @@ function transformDynamicAPI(source, api, filePath) {
             }
         });
     }
-    const isClientComponent = (0, utils_1.determineClientDirective)(root, j, source);
+    const isClientComponent = (0, utils_1.determineClientDirective)(root, j);
     // Only transform the valid calls in server or shared components
     if (isClientComponent)
         return null;
@@ -219,10 +219,7 @@ function castTypesOrAddComment(j, path, originRequestApiName, root, filePath, in
     }
     else {
         // Otherwise for JS file, leave a message to the user to manually handle the transformation
-        path.node.comments = [
-            j.commentBlock(customMessage),
-            ...(path.node.comments || []),
-        ];
+        (0, utils_1.insertCommentOnce)(path.node, j, customMessage);
     }
 }
 function findImportMappingFromNextHeaders(root, j) {

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

@@ -89,7 +89,87 @@ function applyUseAndRenameAccessedProp(propIdName, path, j) {
     }
     return modified;
 }
-function transformDynamicProps(source, api, _filePath) {
+const MATCHED_FILE_PATTERNS = /([\\/]|^)(page|layout)\.(t|j)sx?$/;
+function modifyTypes(paramTypeAnnotation, propsIdentifier, root, j) {
+    if (paramTypeAnnotation && paramTypeAnnotation.typeAnnotation) {
+        const typeAnnotation = paramTypeAnnotation.typeAnnotation;
+        if (typeAnnotation.type === 'TSTypeLiteral') {
+            const typeLiteral = typeAnnotation;
+            // Find the type property for `params`
+            typeLiteral.members.forEach((member) => {
+                if (member.type === 'TSPropertySignature' &&
+                    member.key.type === 'Identifier' &&
+                    utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
+                    // if it's already a Promise, don't wrap it again, return
+                    if (member.typeAnnotation &&
+                        member.typeAnnotation.typeAnnotation &&
+                        member.typeAnnotation.typeAnnotation.type === 'TSTypeReference' &&
+                        member.typeAnnotation.typeAnnotation.typeName.type ===
+                            'Identifier' &&
+                        member.typeAnnotation.typeAnnotation.typeName.name === 'Promise') {
+                        return;
+                    }
+                    // Wrap the `params` type in Promise<>
+                    if (member.typeAnnotation &&
+                        member.typeAnnotation.typeAnnotation &&
+                        j.TSType.check(member.typeAnnotation.typeAnnotation)) {
+                        member.typeAnnotation.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
+                            // @ts-ignore
+                            member.typeAnnotation.typeAnnotation,
+                        ]));
+                    }
+                }
+            });
+        }
+        else if (typeAnnotation.type === 'TSTypeReference') {
+            // If typeAnnotation is a type or interface, change the properties to Promise<type of property>
+            // e.g. interface PageProps { params: { slug: string } } => interface PageProps { params: Promise<{ slug: string }> }
+            const typeReference = typeAnnotation;
+            if (typeReference.typeName.type === 'Identifier') {
+                // Find the actual type of the type reference
+                const foundTypes = findAllTypes(root, j, typeReference.typeName.name);
+                // Deal with interfaces
+                if (foundTypes.interfaces.length > 0) {
+                    const interfaceDeclaration = foundTypes.interfaces[0];
+                    if (interfaceDeclaration.type === 'TSInterfaceDeclaration' &&
+                        interfaceDeclaration.body?.type === 'TSInterfaceBody') {
+                        const typeBody = interfaceDeclaration.body.body;
+                        // if it's already a Promise, don't wrap it again, return
+                        // traverse the typeReference's properties, if any is in propNames, wrap it in Promise<> if needed
+                        typeBody.forEach((member) => {
+                            if (member.type === 'TSPropertySignature' &&
+                                member.key.type === 'Identifier' &&
+                                utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
+                                // if it's already a Promise, don't wrap it again, return
+                                if (member.typeAnnotation &&
+                                    member.typeAnnotation.typeAnnotation &&
+                                    member.typeAnnotation?.typeAnnotation?.typeName?.name ===
+                                        'Promise') {
+                                    return;
+                                }
+                                // Wrap the prop type in Promise<>
+                                if (member.typeAnnotation &&
+                                    member.typeAnnotation.typeAnnotation &&
+                                    // check if member name is in propNames
+                                    utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
+                                    member.typeAnnotation.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
+                                        member.typeAnnotation.typeAnnotation,
+                                    ]));
+                                }
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        propsIdentifier.typeAnnotation = paramTypeAnnotation;
+    }
+}
+function transformDynamicProps(source, api, filePath) {
+    const isMatched = MATCHED_FILE_PATTERNS.test(filePath);
+    if (!isMatched) {
+        return null;
+    }
     let modified = false;
     let modifiedPropArgument = false;
     const j = api.jscodeshift.withParser('tsx');
@@ -100,29 +180,39 @@ function transformDynamicProps(source, api, _filePath) {
     // e.g. destruct `params` { slug } = params
     // e.g. destruct `searchParams `{ search } = searchParams
     let insertedDestructPropNames = new Set();
-    // Rename props to `prop` argument for the function
-    let insertedRenamedPropFunctionNames = new Set();
     function processAsyncPropOfEntryFile(isClientComponent) {
         // find `params` and `searchParams` in file, and transform the access to them
         function renameAsyncPropIfExisted(path, isDefaultExport) {
             const decl = path.value;
             const params = decl.params;
-            const functionName = decl.id?.name || 'default';
+            let functionName = decl.id?.name;
+            // If it's const <id> = function () {}, locate the <id> to get function name
+            if (!decl.id) {
+                functionName = (0, utils_1.getVariableDeclaratorId)(path, j)?.name;
+            }
             // target properties mapping, only contains `params` and `searchParams`
             const propertiesMap = new Map();
             let allProperties = [];
+            const isRoute = !isDefaultExport && utils_1.TARGET_ROUTE_EXPORTS.has(functionName);
             // generateMetadata API has 2 params
             if (functionName === 'generateMetadata') {
                 if (params.length > 2 || params.length === 0)
                     return;
             }
+            else if (isRoute) {
+                if (params.length !== 2)
+                    return;
+            }
             else {
-                // Page/Layout/Route handlers have 1 param
+                // Page/Layout default export have 1 param
                 if (params.length !== 1)
                     return;
             }
             const propsIdentifier = (0, utils_1.generateUniqueIdentifier)(PAGE_PROPS, path, j);
-            const currentParam = params[0];
+            const propsArgumentIndex = isRoute ? 1 : 0;
+            const currentParam = params[propsArgumentIndex];
+            if (!currentParam)
+                return;
             // Argument destructuring case
             if (currentParam.type === 'ObjectPattern') {
                 // Validate if the properties are not `params` and `searchParams`,
@@ -150,85 +240,9 @@ function transformDynamicProps(source, api, _filePath) {
                         propertiesMap.set(prop.key.name, value);
                     }
                 });
-                const paramTypeAnnotation = currentParam.typeAnnotation;
-                if (paramTypeAnnotation && paramTypeAnnotation.typeAnnotation) {
-                    const typeAnnotation = paramTypeAnnotation.typeAnnotation;
-                    if (typeAnnotation.type === 'TSTypeLiteral') {
-                        const typeLiteral = typeAnnotation;
-                        // Find the type property for `params`
-                        typeLiteral.members.forEach((member) => {
-                            if (member.type === 'TSPropertySignature' &&
-                                member.key.type === 'Identifier' &&
-                                propertiesMap.has(member.key.name)) {
-                                // if it's already a Promise, don't wrap it again, return
-                                if (member.typeAnnotation &&
-                                    member.typeAnnotation.typeAnnotation &&
-                                    member.typeAnnotation.typeAnnotation.type ===
-                                        'TSTypeReference' &&
-                                    member.typeAnnotation.typeAnnotation.typeName.type ===
-                                        'Identifier' &&
-                                    member.typeAnnotation.typeAnnotation.typeName.name ===
-                                        'Promise') {
-                                    return;
-                                }
-                                // Wrap the `params` type in Promise<>
-                                if (member.typeAnnotation &&
-                                    member.typeAnnotation.typeAnnotation &&
-                                    j.TSType.check(member.typeAnnotation.typeAnnotation)) {
-                                    member.typeAnnotation.typeAnnotation = j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
-                                        // @ts-ignore
-                                        member.typeAnnotation.typeAnnotation,
-                                    ]));
-                                }
-                            }
-                        });
-                    }
-                    else if (typeAnnotation.type === 'TSTypeReference') {
-                        // If typeAnnotation is a type or interface, change the properties to Promise<type of property>
-                        // e.g. interface PageProps { params: { slug: string } } => interface PageProps { params: Promise<{ slug: string }> }
-                        const typeReference = typeAnnotation;
-                        if (typeReference.typeName.type === 'Identifier') {
-                            // Find the actual type of the type reference
-                            const foundTypes = findAllTypes(root, j, typeReference.typeName.name);
-                            // Deal with interfaces
-                            if (foundTypes.interfaces.length > 0) {
-                                const interfaceDeclaration = foundTypes.interfaces[0];
-                                if (interfaceDeclaration.type === 'TSInterfaceDeclaration' &&
-                                    interfaceDeclaration.body?.type === 'TSInterfaceBody') {
-                                    const typeBody = interfaceDeclaration.body.body;
-                                    // if it's already a Promise, don't wrap it again, return
-                                    // traverse the typeReference's properties, if any is in propNames, wrap it in Promise<> if needed
-                                    typeBody.forEach((member) => {
-                                        if (member.type === 'TSPropertySignature' &&
-                                            member.key.type === 'Identifier' &&
-                                            utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
-                                            // if it's already a Promise, don't wrap it again, return
-                                            if (member.typeAnnotation &&
-                                                member.typeAnnotation.typeAnnotation &&
-                                                member.typeAnnotation?.typeAnnotation?.typeName
-                                                    ?.name === 'Promise') {
-                                                return;
-                                            }
-                                            // Wrap the prop type in Promise<>
-                                            if (member.typeAnnotation &&
-                                                member.typeAnnotation.typeAnnotation &&
-                                                // check if member name is in propNames
-                                                utils_1.TARGET_PROP_NAMES.has(member.key.name)) {
-                                                member.typeAnnotation.typeAnnotation =
-                                                    j.tsTypeReference(j.identifier('Promise'), j.tsTypeParameterInstantiation([
-                                                        member.typeAnnotation.typeAnnotation,
-                                                    ]));
-                                            }
-                                        }
-                                    });
-                                }
-                            }
-                        }
-                    }
-                    propsIdentifier.typeAnnotation = paramTypeAnnotation;
-                }
+                modifyTypes(currentParam.typeAnnotation, propsIdentifier, root, j);
                 // Override the first param to `props`
-                params[0] = propsIdentifier;
+                params[propsArgumentIndex] = propsIdentifier;
                 modified = true;
                 modifiedPropArgument = true;
             }
@@ -264,14 +278,13 @@ function transformDynamicProps(source, api, _filePath) {
                     // find the argument `currentParam`
                     const args = callExpression.value.arguments;
                     const propPassedAsArg = args.find((arg) => j.Identifier.check(arg) && arg.name === argName);
-                    // insert a comment to the argument
-                    const comment = j.commentBlock(` '${argName}' is passed as an argument. Any asynchronous properties of 'props' must be awaited when accessed. `, true, false);
-                    propPassedAsArg.comments = [
-                        comment,
-                        ...(propPassedAsArg.comments || []),
-                    ];
+                    const comment = ` '${argName}' is passed as an argument. Any asynchronous properties of 'props' must be awaited when accessed. `;
+                    (0, utils_1.insertCommentOnce)(propPassedAsArg, j, comment);
                     modified = true;
                 });
+                if (modified) {
+                    modifyTypes(currentParam.typeAnnotation, propsIdentifier, root, j);
+                }
             }
             if (modifiedPropArgument) {
                 resolveAsyncProp(path, propertiesMap, propsIdentifier.name, allProperties, isDefaultExport);
@@ -279,6 +292,8 @@ function transformDynamicProps(source, api, _filePath) {
         }
         // Helper function to insert `const params = await asyncParams;` at the beginning of the function body
         function resolveAsyncProp(path, propertiesMap, propsIdentifierName, allProperties, isDefaultExport) {
+            // Rename props to `prop` argument for the function
+            const insertedRenamedPropFunctionNames = new Set();
             const node = path.value;
             // If it's sync default export, and it's also server component, make the function async
             if (isDefaultExport && !isClientComponent) {
@@ -289,6 +304,27 @@ function transformDynamicProps(source, api, _filePath) {
                     }
                 }
             }
+            // If it's arrow function and function body is not block statement, check if the properties are used there
+            if (j.ArrowFunctionExpression.check(path.node) &&
+                !j.BlockStatement.check(path.node.body)) {
+                const objectExpression = path.node.body;
+                let hasUsedProps = false;
+                j(objectExpression)
+                    .find(j.Identifier)
+                    .forEach((identifierPath) => {
+                    const idName = identifierPath.value.name;
+                    if (propertiesMap.has(idName)) {
+                        hasUsedProps = true;
+                        return;
+                    }
+                });
+                // Turn the function body to block statement, return the object expression
+                if (hasUsedProps) {
+                    path.node.body = j.blockStatement([
+                        j.returnStatement(objectExpression),
+                    ]);
+                }
+            }
             const isAsyncFunc = !!node.async;
             const functionName = path.value.id?.name || 'default';
             const functionBody = findFunctionBody(path);
@@ -448,7 +484,7 @@ function transformDynamicProps(source, api, _filePath) {
             }
         });
     }
-    const isClientComponent = (0, utils_1.determineClientDirective)(root, j, source);
+    const isClientComponent = (0, utils_1.determineClientDirective)(root, j);
     // Apply to `params` and `searchParams`
     processAsyncPropOfEntryFile(isClientComponent);
     // Add import { use } from 'react' if needed and not already imported

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TARGET_PROP_NAMES = exports.TARGET_NAMED_EXPORTS = void 0;
+exports.TARGET_PROP_NAMES = exports.TARGET_NAMED_EXPORTS = exports.TARGET_ROUTE_EXPORTS = void 0;
 exports.isFunctionType = isFunctionType;
 exports.isMatchedFunctionExported = isMatchedFunctionExported;
 exports.determineClientDirective = determineClientDirective;
@@ -13,17 +13,20 @@ exports.findClosetParentFunctionScope = findClosetParentFunctionScope;
 exports.getFunctionPathFromExportPath = getFunctionPathFromExportPath;
 exports.wrapParentheseIfNeeded = wrapParentheseIfNeeded;
 exports.insertCommentOnce = insertCommentOnce;
-exports.TARGET_NAMED_EXPORTS = new Set([
-    // For custom route
+exports.getVariableDeclaratorId = getVariableDeclaratorId;
+exports.TARGET_ROUTE_EXPORTS = new Set([
     'GET',
-    'HEAD',
     'POST',
     'PUT',
-    'DELETE',
     'PATCH',
+    'DELETE',
     'OPTIONS',
+    'HEAD',
+]);
+exports.TARGET_NAMED_EXPORTS = new Set([
     // For page and layout
     'generateMetadata',
+    ...exports.TARGET_ROUTE_EXPORTS,
 ]);
 exports.TARGET_PROP_NAMES = new Set(['params', 'searchParams']);
 function isFunctionType(type) {
@@ -87,31 +90,15 @@ function isMatchedFunctionExported(path, j) {
         return true;
     return isNamedExport;
 }
-function determineClientDirective(root, j, source) {
-    const hasStringDirective = root
-        .find(j.Literal)
-        .filter((path) => {
-        const expr = path.node;
-        return (expr.value === 'use client' && path.parentPath.node.type === 'Program');
-    })
-        .size() > 0;
-    // 'use client';
-    const hasStringDirectiveWithSemicolon = root
-        .find(j.StringLiteral)
-        .filter((path) => {
-        const expr = path.node;
-        return (expr.type === 'StringLiteral' &&
-            expr.value === 'use client' &&
-            path.parentPath.node.type === 'Program');
-    })
-        .size() > 0;
-    if (hasStringDirective || hasStringDirectiveWithSemicolon)
-        return true;
-    // Since the client detection is not reliable with AST in jscodeshift,
-    // determine if 'use client' or "use client" is leading in the source code.
-    const trimmedSource = source.trim();
-    const containsClientDirective = /^'use client'/.test(trimmedSource) || /^"use client"/g.test(trimmedSource);
-    return containsClientDirective;
+// 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' &&
@@ -338,13 +325,23 @@ function getFunctionPathFromExportPath(exportPath, j, root, namedExportFilter) {
 function wrapParentheseIfNeeded(hasChainAccess, j, expression) {
     return hasChainAccess ? j.parenthesizedExpression(expression) : expression;
 }
-function insertCommentOnce(path, j, comment) {
-    if (path.node.comments) {
-        const hasComment = path.node.comments.some((commentNode) => commentNode.value === comment);
+function insertCommentOnce(node, j, comment) {
+    if (node.comments) {
+        const hasComment = node.comments.some((commentNode) => commentNode.value === comment);
         if (hasComment) {
             return;
         }
     }
-    path.node.comments = [j.commentBlock(comment), ...(path.node.comments || [])];
+    node.comments = [j.commentBlock(comment), ...(node.comments || [])];
+}
+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