@next/codemod 15.0.0-canary.18 → 15.0.0-canary.182

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

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const GEO = 'geo';
+const IP = 'ip';
+const GEOLOCATION = 'geolocation';
+const IP_ADDRESS = 'ipAddress';
+const GEO_TYPE = 'Geo';
+function default_1(fileInfo, api) {
+    const j = api.jscodeshift.withParser('tsx');
+    const root = j(fileInfo.source);
+    if (!root.length) {
+        return fileInfo.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 fileInfo.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

package/bin/cli.js

@@ -1,216 +0,0 @@
-"use strict";
-/**
- * Copyright 2015-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-// Based on https://github.com/reactjs/react-codemod/blob/dd8671c9a470a2c342b221ec903c574cf31e9f57/bin/cli.js
-// @next/codemod optional-name-of-transform optional/path/to/src [...options]
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = exports.runTransform = exports.checkGitStatus = exports.transformerDirectory = exports.jscodeshiftExecutable = void 0;
-const globby_1 = __importDefault(require("globby"));
-const inquirer_1 = __importDefault(require("inquirer"));
-const meow_1 = __importDefault(require("meow"));
-const path_1 = __importDefault(require("path"));
-const execa_1 = __importDefault(require("execa"));
-const picocolors_1 = require("picocolors");
-const is_git_clean_1 = __importDefault(require("is-git-clean"));
-const uninstall_package_1 = require("../lib/uninstall-package");
-exports.jscodeshiftExecutable = require.resolve('.bin/jscodeshift');
-exports.transformerDirectory = path_1.default.join(__dirname, '../', 'transforms');
-function checkGitStatus(force) {
-    let clean = false;
-    let errorMessage = 'Unable to determine if git directory is clean';
-    try {
-        clean = is_git_clean_1.default.sync(process.cwd());
-        errorMessage = 'Git directory is not clean';
-    }
-    catch (err) {
-        if (err && err.stderr && err.stderr.includes('Not a git repository')) {
-            clean = true;
-        }
-    }
-    if (!clean) {
-        if (force) {
-            console.log(`WARNING: ${errorMessage}. Forcibly continuing.`);
-        }
-        else {
-            console.log('Thank you for using @next/codemod!');
-            console.log((0, picocolors_1.yellow)('\nBut before we continue, please stash or commit your git changes.'));
-            console.log('\nYou may use the --force flag to override this safety check.');
-            process.exit(1);
-        }
-    }
-}
-exports.checkGitStatus = checkGitStatus;
-function runTransform({ files, flags, transformer }) {
-    const transformerPath = path_1.default.join(exports.transformerDirectory, `${transformer}.js`);
-    if (transformer === 'cra-to-next') {
-        // cra-to-next transform doesn't use jscodeshift directly
-        return require(transformerPath).default(files, flags);
-    }
-    let args = [];
-    const { dry, print, runInBand } = flags;
-    if (dry) {
-        args.push('--dry');
-    }
-    if (print) {
-        args.push('--print');
-    }
-    if (runInBand) {
-        args.push('--run-in-band');
-    }
-    args.push('--verbose=2');
-    args.push('--ignore-pattern=**/node_modules/**');
-    args.push('--ignore-pattern=**/.next/**');
-    args.push('--extensions=tsx,ts,jsx,js');
-    args = args.concat(['--transform', transformerPath]);
-    if (flags.jscodeshift) {
-        args = args.concat(flags.jscodeshift);
-    }
-    args = args.concat(files);
-    console.log(`Executing command: jscodeshift ${args.join(' ')}`);
-    const result = execa_1.default.sync(exports.jscodeshiftExecutable, args, {
-        stdio: 'inherit',
-        stripFinalNewline: false,
-    });
-    if (result.failed) {
-        throw new Error(`jscodeshift exited with code ${result.exitCode}`);
-    }
-    if (!dry && transformer === 'built-in-next-font') {
-        console.log('Uninstalling `@next/font`');
-        try {
-            (0, uninstall_package_1.uninstallPackage)('@next/font');
-        }
-        catch (_a) {
-            console.error("Couldn't uninstall `@next/font`, please uninstall it manually");
-        }
-    }
-}
-exports.runTransform = runTransform;
-const TRANSFORMER_INQUIRER_CHOICES = [
-    {
-        name: 'name-default-component: Transforms anonymous components into named components to make sure they work with Fast Refresh',
-        value: 'name-default-component',
-    },
-    {
-        name: 'add-missing-react-import: Transforms files that do not import `React` to include the import in order for the new React JSX transform',
-        value: 'add-missing-react-import',
-    },
-    {
-        name: 'withamp-to-config: Transforms the withAmp HOC into Next.js 9 page configuration',
-        value: 'withamp-to-config',
-    },
-    {
-        name: 'url-to-withrouter: Transforms the deprecated automatically injected url property on top level pages to using withRouter',
-        value: 'url-to-withrouter',
-    },
-    {
-        name: 'cra-to-next (experimental): automatically migrates a Create React App project to Next.js',
-        value: 'cra-to-next',
-    },
-    {
-        name: 'new-link: Ensures your <Link> usage is backwards compatible.',
-        value: 'new-link',
-    },
-    {
-        name: 'next-og-import: Transforms imports from `next/server` to `next/og` for usage of Dynamic OG Image Generation.',
-        value: 'next-og-import',
-    },
-    {
-        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-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',
-    },
-    {
-        name: 'next-image-experimental (experimental): dangerously migrates from `next/legacy/image` to the new `next/image` by adding inline styles and removing unused props',
-        value: 'next-image-experimental',
-    },
-    {
-        name: 'built-in-next-font: Uninstall `@next/font` and transform imports to `next/font`',
-        value: 'built-in-next-font',
-    },
-];
-function expandFilePathsIfNeeded(filesBeforeExpansion) {
-    const shouldExpandFiles = filesBeforeExpansion.some((file) => file.includes('*'));
-    return shouldExpandFiles
-        ? globby_1.default.sync(filesBeforeExpansion)
-        : filesBeforeExpansion;
-}
-function run() {
-    const cli = (0, meow_1.default)({
-        description: 'Codemods for updating Next.js apps.',
-        help: `
-    Usage
-      $ npx @next/codemod <transform> <path> <...options>
-        transform    One of the choices from https://github.com/vercel/next.js/tree/canary/packages/next-codemod
-        path         Files or directory to transform. Can be a glob like pages/**.js
-    Options
-      --force            Bypass Git safety checks and forcibly run codemods
-      --dry              Dry run (no changes are made to files)
-      --print            Print transformed files to your terminal
-      --jscodeshift  (Advanced) Pass options directly to jscodeshift
-    `,
-        flags: {
-            boolean: ['force', 'dry', 'print', 'help'],
-            string: ['_'],
-            alias: {
-                h: 'help',
-            },
-        },
-    });
-    if (!cli.flags.dry) {
-        checkGitStatus(cli.flags.force);
-    }
-    if (cli.input[0] &&
-        !TRANSFORMER_INQUIRER_CHOICES.find((x) => x.value === cli.input[0])) {
-        console.error('Invalid transform choice, pick one of:');
-        console.error(TRANSFORMER_INQUIRER_CHOICES.map((x) => '- ' + x.value).join('\n'));
-        process.exit(1);
-    }
-    inquirer_1.default
-        .prompt([
-        {
-            type: 'input',
-            name: 'files',
-            message: 'On which files or directory should the codemods be applied?',
-            when: !cli.input[1],
-            default: '.',
-            // validate: () =>
-            filter: (files) => files.trim(),
-        },
-        {
-            type: 'list',
-            name: 'transformer',
-            message: 'Which transform would you like to apply?',
-            when: !cli.input[0],
-            pageSize: TRANSFORMER_INQUIRER_CHOICES.length,
-            choices: TRANSFORMER_INQUIRER_CHOICES,
-        },
-    ])
-        .then((answers) => {
-        const { files, transformer } = answers;
-        const filesBeforeExpansion = cli.input[1] || files;
-        const filesExpanded = expandFilePathsIfNeeded([filesBeforeExpansion]);
-        const selectedTransformer = cli.input[0] || transformer;
-        if (!filesExpanded.length) {
-            console.log(`No files found matching ${filesBeforeExpansion.join(' ')}`);
-            return null;
-        }
-        return runTransform({
-            files: filesExpanded,
-            flags: cli.flags,
-            transformer: selectedTransformer,
-        });
-    });
-}
-exports.run = run;
-//# sourceMappingURL=cli.js.map

package/lib/uninstall-package.js

@@ -1,32 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uninstallPackage = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const execa_1 = __importDefault(require("execa"));
-function getPkgManager(baseDir) {
-    for (const { lockFile, packageManager } of [
-        { lockFile: 'yarn.lock', packageManager: 'yarn' },
-        { lockFile: 'pnpm-lock.yaml', packageManager: 'pnpm' },
-        { lockFile: 'package-lock.json', packageManager: 'npm' },
-    ]) {
-        if (fs_1.default.existsSync(path_1.default.join(baseDir, lockFile))) {
-            return packageManager;
-        }
-    }
-}
-function uninstallPackage(packageToUninstall) {
-    const pkgManager = getPkgManager(process.cwd());
-    if (!pkgManager)
-        throw new Error('Failed to find package manager');
-    let command = 'uninstall';
-    if (pkgManager === 'yarn') {
-        command = 'remove';
-    }
-    execa_1.default.sync(pkgManager, [command, packageToUninstall], { stdio: 'inherit' });
-}
-exports.uninstallPackage = uninstallPackage;
-//# sourceMappingURL=uninstall-package.js.map