@next/codemod 15.0.0-canary.2 → 15.0.0-canary.200

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

package/transforms/next-image-to-legacy-image.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function transformer(file, api, options) {
-    const j = api.jscodeshift.withParser('tsx');
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
     // Before: import Image from "next/image"
     //  After: import Image from "next/legacy/image"
@@ -16,7 +18,7 @@ function transformer(file, api, options) {
     //  After: const Image = await import("next/legacy/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/image') {
                 arg.arguments[0] = j.stringLiteral('next/legacy/image');
@@ -36,7 +38,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/future/image') {
                 arg.arguments[0] = j.stringLiteral('next/image');
@@ -46,8 +48,7 @@ function transformer(file, api, options) {
     // Before: const Image = require("next/image")
     //  After: const Image = require("next/legacy/image")
     root.find(j.CallExpression).forEach((requireExp) => {
-        var _a, _b;
-        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 &&
@@ -60,8 +61,7 @@ function transformer(file, api, options) {
     // Before: const Image = require("next/future/image")
     //  After: const Image = require("next/image")
     root.find(j.CallExpression).forEach((requireExp) => {
-        var _a, _b;
-        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 &&
@@ -75,5 +75,4 @@ function transformer(file, api, options) {
     // https://www.codeshiftcommunity.com/docs/import-manipulation/#replacerename-an-import-declaration
     return root.toSource(options);
 }
-exports.default = transformer;
 //# sourceMappingURL=next-image-to-legacy-image.js.map

package/transforms/next-og-import.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
 const importToChange = 'ImageResponse';
-function transformer(file, api) {
-    const j = api.jscodeshift;
+function transformer(file, _api) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
     // Find import declarations that match the pattern
     file.source = j(file.source)
         .find(j.ImportDeclaration, {
@@ -31,5 +33,4 @@ function transformer(file, api) {
         .toSource();
     return file.source;
 }
-exports.default = transformer;
 //# sourceMappingURL=next-og-import.js.map

package/transforms/next-request-geo-ip.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const parser_1 = require("../lib/parser");
+const GEO = 'geo';
+const IP = 'ip';
+const GEOLOCATION = 'geolocation';
+const IP_ADDRESS = 'ipAddress';
+const GEO_TYPE = 'Geo';
+function default_1(file, _api) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
+    const root = j(file.source);
+    if (!root.length) {
+        return file.source;
+    }
+    const nextReqType = root
+        .find(j.FunctionDeclaration)
+        .find(j.Identifier, (id) => {
+        if (id.typeAnnotation?.type !== 'TSTypeAnnotation') {
+            return false;
+        }
+        const typeAnn = id.typeAnnotation.typeAnnotation;
+        return (typeAnn.type === 'TSTypeReference' &&
+            typeAnn.typeName.type === 'Identifier' &&
+            typeAnn.typeName.name === 'NextRequest');
+    });
+    const vercelFuncImports = root.find(j.ImportDeclaration, {
+        source: {
+            value: '@vercel/functions',
+        },
+    });
+    const vercelFuncImportSpecifiers = vercelFuncImports
+        .find(j.ImportSpecifier)
+        .nodes();
+    const vercelFuncImportNames = new Set(vercelFuncImportSpecifiers.map((node) => node.imported.name));
+    const hasGeolocation = vercelFuncImportNames.has(GEOLOCATION);
+    const hasIpAddress = vercelFuncImportNames.has(IP_ADDRESS);
+    const hasGeoType = vercelFuncImportNames.has(GEO_TYPE);
+    let identifierNames = new Set();
+    // if all identifiers are already imported, we don't need to create
+    // a unique identifier for them, therefore we don't look for all
+    // identifier names in the file
+    if (!hasGeolocation || !hasIpAddress || !hasGeoType) {
+        const allIdentifiers = root.find(j.Identifier).nodes();
+        identifierNames = new Set(allIdentifiers.map((node) => node.name));
+    }
+    let geoIdentifier = hasGeolocation
+        ? getExistingIdentifier(vercelFuncImportSpecifiers, GEOLOCATION)
+        : getUniqueIdentifier(identifierNames, GEOLOCATION);
+    let ipIdentifier = hasIpAddress
+        ? getExistingIdentifier(vercelFuncImportSpecifiers, IP_ADDRESS)
+        : getUniqueIdentifier(identifierNames, IP_ADDRESS);
+    let geoTypeIdentifier = hasGeoType
+        ? getExistingIdentifier(vercelFuncImportSpecifiers, GEO_TYPE)
+        : getUniqueIdentifier(identifierNames, GEO_TYPE);
+    let { needImportGeolocation, needImportIpAddress } = replaceGeoIpValues(j, nextReqType, geoIdentifier, ipIdentifier);
+    let { needImportGeoType, hasChangedIpType } = replaceGeoIpTypes(j, root, geoTypeIdentifier);
+    let needChanges = needImportGeolocation ||
+        needImportIpAddress ||
+        needImportGeoType ||
+        hasChangedIpType;
+    if (!needChanges) {
+        return file.source;
+    }
+    // Even if there was a change above, if there's an existing import,
+    // we don't need to import them again.
+    needImportGeolocation = !hasGeolocation && needImportGeolocation;
+    needImportIpAddress = !hasIpAddress && needImportIpAddress;
+    needImportGeoType = !hasGeoType && needImportGeoType;
+    insertImportDeclarations(j, root, vercelFuncImports, needImportGeolocation, needImportIpAddress, needImportGeoType, geoIdentifier, ipIdentifier, geoTypeIdentifier);
+    return root.toSource();
+}
+/**
+ * Returns an existing identifier from the Vercel functions import declaration.
+ */
+function getExistingIdentifier(vercelFuncImportSpecifiers, identifier) {
+    const existingIdentifier = vercelFuncImportSpecifiers.find((node) => node.imported.name === identifier);
+    return (existingIdentifier?.local?.name ||
+        existingIdentifier.imported.name ||
+        identifier);
+}
+/**
+ * Returns a unique identifier by adding a suffix to the original identifier
+ * if it already exists in the set.
+ */
+function getUniqueIdentifier(identifierNames, identifier) {
+    let suffix = 1;
+    let uniqueIdentifier = identifier;
+    while (identifierNames.has(uniqueIdentifier)) {
+        uniqueIdentifier = `${identifier}${suffix}`;
+        suffix++;
+    }
+    return uniqueIdentifier;
+}
+/**
+ * Replaces accessors `geo` and `ip` of NextRequest with corresponding
+ * function calls from `@vercel/functions`.
+ *
+ * Creates new variable declarations for destructuring assignments.
+ */
+function replaceGeoIpValues(j, nextReqType, geoIdentifier, ipIdentifier) {
+    let needImportGeolocation = false;
+    let needImportIpAddress = false;
+    for (const nextReqPath of nextReqType.paths()) {
+        const fnPath = nextReqPath.parentPath.parentPath;
+        const fn = j(fnPath);
+        const blockStatement = fn.find(j.BlockStatement);
+        const varDeclarators = fn.find(j.VariableDeclarator);
+        // req.geo, req.ip
+        const geoAccesses = blockStatement.find(j.MemberExpression, (me) => me.object.type === 'Identifier' &&
+            me.object.name === nextReqPath.node.name &&
+            me.property.type === 'Identifier' &&
+            me.property.name === GEO);
+        const ipAccesses = blockStatement.find(j.MemberExpression, (me) => me.object.type === 'Identifier' &&
+            me.object.name === nextReqPath.node.name &&
+            me.property.type === 'Identifier' &&
+            me.property.name === IP);
+        // var { geo, ip } = req
+        const geoDestructuring = varDeclarators.filter((path) => path.node.id.type === 'ObjectPattern' &&
+            path.node.id.properties.some((prop) => prop.type === 'ObjectProperty' &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === GEO));
+        const ipDestructuring = varDeclarators.filter((path) => path.node.id.type === 'ObjectPattern' &&
+            path.node.id.properties.some((prop) => prop.type === 'ObjectProperty' &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === IP));
+        // geolocation(req), ipAddress(req)
+        const geoCall = j.callExpression(j.identifier(geoIdentifier), [
+            {
+                ...nextReqPath.node,
+                typeAnnotation: null,
+            },
+        ]);
+        const ipCall = j.callExpression(j.identifier(ipIdentifier), [
+            {
+                ...nextReqPath.node,
+                typeAnnotation: null,
+            },
+        ]);
+        geoAccesses.replaceWith(geoCall);
+        ipAccesses.replaceWith(ipCall);
+        /**
+         * For each destructuring assignment, we create a new variable
+         * declaration and insert it after the current block statement.
+         *
+         * Before:
+         *
+         * ```
+         * const { buildId, geo, ip } = req;
+         * ```
+         *
+         * After:
+         *
+         * ```
+         * const { buildId } = req;
+         * const geo = geolocation(req);
+         * const ip = ipAddress(req);
+         * ```
+         */
+        geoDestructuring.forEach((path) => {
+            if (path.node.id.type === 'ObjectPattern') {
+                const properties = path.node.id.properties;
+                const geoProperty = properties.find((prop) => prop.type === 'ObjectProperty' &&
+                    prop.key.type === 'Identifier' &&
+                    prop.key.name === GEO);
+                const otherProperties = properties.filter((prop) => prop !== geoProperty);
+                const geoDeclaration = j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier(
+                    // Use alias from destructuring (if present) to retain references:
+                    // const { geo: geoAlias } = req; -> const geoAlias = geolocation(req);
+                    // This prevents errors from undeclared variables.
+                    geoProperty.type === 'ObjectProperty' &&
+                        geoProperty.value.type === 'Identifier'
+                        ? geoProperty.value.name
+                        : GEO), geoCall),
+                ]);
+                path.node.id.properties = otherProperties;
+                path.parent.insertAfter(geoDeclaration);
+            }
+        });
+        ipDestructuring.forEach((path) => {
+            if (path.node.id.type === 'ObjectPattern') {
+                const properties = path.node.id.properties;
+                const ipProperty = properties.find((prop) => prop.type === 'ObjectProperty' &&
+                    prop.key.type === 'Identifier' &&
+                    prop.key.name === IP);
+                const otherProperties = properties.filter((prop) => prop !== ipProperty);
+                const ipDeclaration = j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier(
+                    // Use alias from destructuring (if present) to retain references:
+                    // const { ip: ipAlias } = req; -> const ipAlias = ipAddress(req);
+                    // This prevents errors from undeclared variables.
+                    ipProperty.type === 'ObjectProperty' &&
+                        ipProperty.value.type === 'Identifier'
+                        ? ipProperty.value.name
+                        : IP), ipCall),
+                ]);
+                path.node.id.properties = otherProperties;
+                path.parent.insertAfter(ipDeclaration);
+            }
+        });
+        needImportGeolocation =
+            needImportGeolocation ||
+                geoAccesses.length > 0 ||
+                geoDestructuring.length > 0;
+        needImportIpAddress =
+            needImportIpAddress || ipAccesses.length > 0 || ipDestructuring.length > 0;
+    }
+    return {
+        needImportGeolocation,
+        needImportIpAddress,
+    };
+}
+/**
+ * Replaces the types of `NextRequest["geo"]` and `NextRequest["ip"]` with
+ * corresponding types from `@vercel/functions`.
+ */
+function replaceGeoIpTypes(j, root, geoTypeIdentifier) {
+    let needImportGeoType = false;
+    let hasChangedIpType = false;
+    // get the type of NextRequest that has accessed for ip and geo
+    // NextRequest['geo'], NextRequest['ip']
+    const nextReqGeoType = root.find(j.TSIndexedAccessType, (tsIndexedAccessType) => {
+        return (tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
+            tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
+            tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
+            tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
+            tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
+            tsIndexedAccessType.indexType.literal.value === GEO);
+    });
+    const nextReqIpType = root.find(j.TSIndexedAccessType, (tsIndexedAccessType) => {
+        return (tsIndexedAccessType.objectType.type === 'TSTypeReference' &&
+            tsIndexedAccessType.objectType.typeName.type === 'Identifier' &&
+            tsIndexedAccessType.objectType.typeName.name === 'NextRequest' &&
+            tsIndexedAccessType.indexType.type === 'TSLiteralType' &&
+            tsIndexedAccessType.indexType.literal.type === 'StringLiteral' &&
+            tsIndexedAccessType.indexType.literal.value === IP);
+    });
+    if (nextReqGeoType.length > 0) {
+        needImportGeoType = true;
+        // replace with type Geo
+        nextReqGeoType.replaceWith(j.identifier(geoTypeIdentifier));
+    }
+    if (nextReqIpType.length > 0) {
+        hasChangedIpType = true;
+        // replace with type string | undefined
+        nextReqIpType.replaceWith(j.tsUnionType([j.tsStringKeyword(), j.tsUndefinedKeyword()]));
+    }
+    return {
+        needImportGeoType,
+        hasChangedIpType,
+    };
+}
+/**
+ * Inserts import declarations from `"@vercel/functions"`.
+ *
+ * For the `Geo` type that needs to be imported to replace `NextRequest["geo"]`,
+ * if it is the only import needed, we import it as a type.
+ *
+ * ```ts
+ * import type { Geo } from "@vercel/functions";
+ * ```
+ *
+ * Otherwise, we import it as an inline type import.
+ *
+ * ```ts
+ * import { type Geo, ... } from "@vercel/functions";
+ * ```
+ */
+function insertImportDeclarations(j, root, vercelFuncImports, needImportGeolocation, needImportIpAddress, needImportGeoType, geoIdentifier, ipIdentifier, geoTypeIdentifier) {
+    // No need inserting import.
+    if (!needImportGeolocation && !needImportIpAddress && !needImportGeoType) {
+        return;
+    }
+    // As we run this only when `NextRequest` is imported, there should be
+    // a "next/server" import.
+    const firstNextServerImport = root
+        .find(j.ImportDeclaration, { source: { value: 'next/server' } })
+        .at(0);
+    const firstVercelFuncImport = vercelFuncImports.at(0);
+    const hasVercelFuncImport = firstVercelFuncImport.length > 0;
+    // If there's no "@vercel/functions" import, and we only need to import
+    // `Geo` type, we create a type import to avoid side effect with
+    // `verbatimModuleSyntax`.
+    // x-ref: https://typescript-eslint.io/rules/no-import-type-side-effects
+    if (!hasVercelFuncImport &&
+        !needImportGeolocation &&
+        !needImportIpAddress &&
+        needImportGeoType) {
+        const geoTypeImportDeclaration = j.importDeclaration([
+            needImportGeoType
+                ? j.importSpecifier(j.identifier(GEO_TYPE), j.identifier(geoTypeIdentifier))
+                : null,
+        ].filter(Boolean), j.literal('@vercel/functions'), 
+        // import type { Geo } ...
+        'type');
+        firstNextServerImport.insertAfter(geoTypeImportDeclaration);
+        return;
+    }
+    const importDeclaration = j.importDeclaration([
+        // If there was a duplicate identifier, we add an
+        // incremental number suffix to it and we use alias:
+        // `import { geolocation as geolocation1 } from ...`
+        needImportGeolocation
+            ? j.importSpecifier(j.identifier(GEOLOCATION), j.identifier(geoIdentifier))
+            : null,
+        needImportIpAddress
+            ? j.importSpecifier(j.identifier(IP_ADDRESS), j.identifier(ipIdentifier))
+            : null,
+        needImportGeoType
+            ? j.importSpecifier(j.identifier(GEO_TYPE), j.identifier(geoTypeIdentifier))
+            : null,
+    ].filter(Boolean), j.literal('@vercel/functions'));
+    if (hasVercelFuncImport) {
+        firstVercelFuncImport
+            .get()
+            .node.specifiers.push(...importDeclaration.specifiers);
+        if (needImportGeoType) {
+            const targetGeo = firstVercelFuncImport
+                .get()
+                .node.specifiers.find((specifier) => specifier.imported.name === GEO_TYPE);
+            if (targetGeo) {
+                targetGeo.importKind = 'type';
+            }
+        }
+    }
+    else {
+        if (needImportGeoType) {
+            const targetGeo = importDeclaration.specifiers.find((specifier) => specifier.type === 'ImportSpecifier' &&
+                specifier.imported.name === GEO_TYPE);
+            if (targetGeo) {
+                // @ts-expect-error -- Missing types in jscodeshift.
+                targetGeo.importKind = 'type';
+            }
+        }
+        firstNextServerImport.insertAfter(importDeclaration);
+    }
+}
+//# sourceMappingURL=next-request-geo-ip.js.map

package/transforms/url-to-withrouter.js

@@ -1,6 +1,7 @@
 "use strict";
 // One-time usage file. You can delete me after running the codemod!
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
 function addWithRouterImport(j, root) {
     // We create an import specifier, this is the value of an import, eg:
     // import {withRouter} from 'next/router
@@ -317,5 +318,4 @@ function transformer(file, api) {
     });
     return root.toSource();
 }
-exports.default = transformer;
 //# sourceMappingURL=url-to-withrouter.js.map

package/transforms/withamp-to-config.js

@@ -1,6 +1,7 @@
 "use strict";
 // One-time usage file. You can delete me after running the codemod!
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
 function injectAmp(j, o, desiredAmpValue) {
     const init = o.node.init;
     switch (init.type) {
@@ -131,5 +132,4 @@ function transformer(file, api) {
     }
     return done();
 }
-exports.default = transformer;
 //# sourceMappingURL=withamp-to-config.js.map