@react-spectrum/codemods 1.0.1 → 1.2.0

package/dist/s1-to-s2/src/codemods/shared/styleProps.js

@@ -680,7 +680,7 @@ function transformStyleProps(path, element) {
         if (isDOMElement) {
             let index = path.node.openingElement.attributes?.findIndex(a => a.type === 'JSXAttribute' && a.name.name === 'className');
             if (index != null && index >= 0) {
-                classNameAttribute = path.get('openingElement').get('attributes').at(index);
+                classNameAttribute = path.get('openingElement').get('attributes')[index];
             }
         }
         let valueToAST = (v) => {

package/dist/s1-to-s2/src/codemods/shared/transforms.js

@@ -45,6 +45,7 @@ exports.updateComponentWithinCollection = updateComponentWithinCollection;
 exports.commentIfParentCollectionNotDetected = commentIfParentCollectionNotDetected;
 exports.movePropToNewChildComponentName = movePropToNewChildComponentName;
 exports.movePropToParentComponent = movePropToParentComponent;
+exports.movePropToChildComponent = movePropToChildComponent;
 exports.updateToNewComponentName = updateToNewComponentName;
 exports.convertDimensionValueToPx = convertDimensionValueToPx;
 exports.updatePlacementToSingleValue = updatePlacementToSingleValue;
@@ -346,9 +347,9 @@ function moveRenderPropsToChild(path, options) {
  */
 function updateComponentWithinCollection(path, options) {
     const { parentComponentName, newComponentName } = options;
-    // Collections currently implemented
-    // TODO: Add 'ActionGroup', 'ListBox', 'ListView' once implemented
-    const collectionItemParents = new Set(['Menu', 'ActionMenu', 'TagGroup', 'Breadcrumbs', 'Picker', 'ComboBox', 'ListBox', 'TabList', 'TabPanels', 'Collection']);
+    // Collections currently implemented.
+    // TODO: Add 'ActionGroup', 'ListBox' once implemented
+    const collectionItemParents = new Set(['Menu', 'ActionMenu', 'TagGroup', 'Breadcrumbs', 'Picker', 'ComboBox', 'ListBox', 'ListView', 'TabList', 'TabPanels', 'Collection', 'ContextualHelpTrigger']);
     if (t.isJSXElement(path.node) &&
         t.isJSXIdentifier(path.node.openingElement.name)) {
         // Find closest parent collection component
@@ -377,7 +378,7 @@ function updateComponentWithinCollection(path, options) {
  * Example: If they're declaring declaring Items somewhere above the collection.
  */
 function commentIfParentCollectionNotDetected(path) {
-    const collectionItemParents = new Set(['Menu', 'ActionMenu', 'TagGroup', 'Breadcrumbs', 'Picker', 'ComboBox', 'ListBox', 'TabList', 'TabPanels', 'ActionGroup', 'ActionButtonGroup', 'ToggleButtonGroup', 'ListBox', 'ListView', 'Collection', 'SearchAutocomplete', 'Accordion', 'ActionBar', 'StepList']);
+    const collectionItemParents = new Set(['Menu', 'ActionMenu', 'TagGroup', 'Breadcrumbs', 'Picker', 'ComboBox', 'ListBox', 'TabList', 'TabPanels', 'ActionGroup', 'ActionButtonGroup', 'ToggleButtonGroup', 'ListBox', 'ListView', 'Collection', 'SearchAutocomplete', 'Accordion', 'ActionBar', 'StepList', 'ContextualHelpTrigger']);
     if (t.isJSXElement(path.node)) {
         // Find closest parent collection component
         let closestParentCollection = path.findParent((p) => t.isJSXElement(p.node) &&
@@ -404,6 +405,7 @@ function movePropToNewChildComponentName(path, options) {
         (0, utils_1.getName)(path, path.node.openingElement.name) === childComponentName &&
         (0, utils_1.getName)(path, path.parentPath.node.openingElement.name) === parentComponentName) {
         let propValue;
+        let localName = newChildComponentName;
         path.node.openingElement.attributes =
             path.node.openingElement.attributes.filter((attr) => {
                 if (t.isJSXAttribute(attr) && attr.name.name === propName) {
@@ -413,7 +415,11 @@ function movePropToNewChildComponentName(path, options) {
                 return true;
             });
         if (propValue) {
-            path.node.children.unshift(t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(newChildComponentName), []), t.jsxClosingElement(t.jsxIdentifier(newChildComponentName)), [t.isStringLiteral(propValue) ? t.jsxText(propValue.value) : propValue]));
+            if (availableComponents.has(newChildComponentName)) {
+                let program = path.findParent((p) => t.isProgram(p.node));
+                localName = (0, utils_1.addComponentImport)(program, newChildComponentName);
+            }
+            path.node.children.unshift(t.jsxElement(t.jsxOpeningElement(t.jsxIdentifier(localName), []), t.jsxClosingElement(t.jsxIdentifier(localName)), [t.isStringLiteral(propValue) ? t.jsxText(propValue.value) : propValue]));
             // TODO: handle dynamic collections. Need to wrap export function child in <Collection> and move `items` prop down.
         }
     }
@@ -440,6 +446,35 @@ function movePropToParentComponent(path, options) {
         }
     });
 }
+/**
+ * Moves a prop from the parent component onto a direct child JSX element.
+ *
+ * Example:
+ * - MenuTrigger: Remove `shouldCloseOnSelect` and add it to the child `Menu` instead.
+ */
+function movePropToChildComponent(path, options) {
+    const { parentComponentName, childComponentName, propName } = options;
+    if (!t.isJSXIdentifier(path.node.openingElement.name) ||
+        (0, utils_1.getName)(path, path.node.openingElement.name) !== parentComponentName) {
+        return;
+    }
+    let attrs = path.node.openingElement.attributes;
+    let propAttr = attrs.find((attr) => t.isJSXAttribute(attr) && attr.name.name === propName);
+    if (!propAttr) {
+        return;
+    }
+    let childPath = path.get('children').find((child) => child.isJSXElement() &&
+        t.isJSXIdentifier(child.node.openingElement.name) &&
+        (0, utils_1.getName)(path, child.node.openingElement.name) === childComponentName);
+    if (!childPath?.isJSXElement()) {
+        return;
+    }
+    childPath.node.openingElement.attributes.push(t.jsxAttribute(t.jsxIdentifier(propName), propAttr.value));
+    let index = attrs.indexOf(propAttr);
+    if (index !== -1) {
+        attrs.splice(index, 1);
+    }
+}
 /**
  * Update to use a new component.
  *

package/dist/s1-to-s2/src/codemods/shared/utils.js

@@ -39,6 +39,8 @@ exports.capitalize = capitalize;
 exports.addComment = addComment;
 exports.addComponentImport = addComponentImport;
 exports.removeComponentImport = removeComponentImport;
+exports.removeComponentImportIfUnused = removeComponentImportIfUnused;
+exports.removeUnusedImports = removeUnusedImports;
 exports.getName = getName;
 const t = __importStar(require("@babel/types"));
 function getPropValue(node) {
@@ -108,6 +110,17 @@ function addComment(node, comment) {
     });
 }
 function addComponentImport(path, newComponentName) {
+    let existingImport = path.node.body.find((node) => t.isImportDeclaration(node) && node.source.value === '@react-spectrum/s2');
+    if (existingImport && t.isImportDeclaration(existingImport)) {
+        let existingSpecifier = existingImport.specifiers.find((specifier) => {
+            return (t.isImportSpecifier(specifier) &&
+                specifier.imported.type === 'Identifier' &&
+                specifier.imported.name === newComponentName);
+        });
+        if (existingSpecifier && t.isImportSpecifier(existingSpecifier)) {
+            return existingSpecifier.local?.name ?? newComponentName;
+        }
+    }
     // If newComponentName variable already exists in scope, alias new import to avoid conflict.
     let existingBinding = path.scope.getBinding(newComponentName);
     let localName = newComponentName;
@@ -120,17 +133,7 @@ function addComponentImport(path, newComponentName) {
         }
         localName = newName;
     }
-    let existingImport = path.node.body.find((node) => t.isImportDeclaration(node) && node.source.value === '@react-spectrum/s2');
     if (existingImport && t.isImportDeclaration(existingImport)) {
-        let specifier = existingImport.specifiers.find((specifier) => {
-            return (t.isImportSpecifier(specifier) &&
-                specifier.imported.type === 'Identifier' &&
-                specifier.imported.name === newComponentName);
-        });
-        if (specifier) {
-            // Already imported
-            return localName;
-        }
         existingImport.specifiers.push(t.importSpecifier(t.identifier(localName), t.identifier(newComponentName)));
     }
     else {
@@ -142,18 +145,66 @@ function addComponentImport(path, newComponentName) {
     return localName;
 }
 function removeComponentImport(path, component) {
-    let existingImport = path.node.body.find((node) => t.isImportDeclaration(node) && node.source.value === '@adobe/react-spectrum' || t.isImportDeclaration(node) && node.source.value.startsWith('@react-spectrum/'));
-    if (existingImport && t.isImportDeclaration(existingImport)) {
-        let specifier = existingImport.specifiers.find((specifier) => {
-            return (t.isImportSpecifier(specifier) &&
-                specifier.imported.type === 'Identifier' &&
-                specifier.imported.name === component);
+    let imports = path.node.body.filter((node) => {
+        return t.isImportDeclaration(node)
+            && (node.source.value === '@adobe/react-spectrum'
+                || (node.source.value.startsWith('@react-spectrum/') && node.source.value !== '@react-spectrum/s2'));
+    });
+    for (let importDecl of imports) {
+        let previousLength = importDecl.specifiers.length;
+        importDecl.specifiers = importDecl.specifiers.filter((specifier) => {
+            return !(t.isImportSpecifier(specifier)
+                && specifier.imported.type === 'Identifier'
+                && specifier.imported.name === component);
+        });
+        if (importDecl.specifiers.length === 0 && previousLength > 0) {
+            path.node.body = path.node.body.filter((node) => node !== importDecl);
+        }
+    }
+}
+function removeComponentImportIfUnused(path, component) {
+    path.scope.crawl();
+    let imports = path.node.body.filter((node) => {
+        return t.isImportDeclaration(node)
+            && (node.source.value === '@adobe/react-spectrum'
+                || node.source.value.startsWith('@react-spectrum/'));
+    });
+    for (let importDecl of imports) {
+        let previousLength = importDecl.specifiers.length;
+        importDecl.specifiers = importDecl.specifiers.filter((specifier) => {
+            if (t.isImportSpecifier(specifier)
+                && specifier.imported.type === 'Identifier'
+                && specifier.imported.name === component) {
+                let localName = specifier.local?.name ?? specifier.imported.name;
+                let binding = path.scope.getBinding(localName);
+                return !!binding?.referencePaths.length;
+            }
+            return true;
         });
-        if (specifier) {
-            existingImport.specifiers = existingImport.specifiers.filter((s) => s !== specifier);
-            if (existingImport.specifiers.length === 0) {
-                path.node.body = path.node.body.filter((node) => node !== existingImport);
+        if (importDecl.specifiers.length === 0 && previousLength > 0) {
+            path.node.body = path.node.body.filter((node) => node !== importDecl);
+        }
+    }
+}
+function removeUnusedImports(path, sources) {
+    path.scope.crawl();
+    let sourceSet = new Set(sources);
+    let imports = path.node.body.filter((node) => {
+        return t.isImportDeclaration(node) && sourceSet.has(node.source.value);
+    });
+    for (let importDecl of imports) {
+        let previousLength = importDecl.specifiers.length;
+        importDecl.specifiers = importDecl.specifiers.filter((specifier) => {
+            if (t.isImportSpecifier(specifier)
+                || t.isImportDefaultSpecifier(specifier)
+                || t.isImportNamespaceSpecifier(specifier)) {
+                let binding = path.scope.getBinding(specifier.local.name);
+                return !!binding?.referencePaths.length;
             }
+            return true;
+        });
+        if (importDecl.specifiers.length === 0 && previousLength > 0) {
+            path.node.body = path.node.body.filter((node) => node !== importDecl);
         }
     }
 }

package/dist/s1-to-s2/src/getComponents.js

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getComponents = getComponents;
+const fs_1 = require("fs");
 const parser_1 = require("@babel/parser");
 const path = require('path');
-const fs_1 = require("fs");
 const traverse_1 = __importDefault(require("@babel/traverse"));
 // These are exported but there are no codemods written for them yet.
 // Don't replace imports yet.
@@ -19,8 +19,18 @@ const skipped = new Set([
 function getComponents() {
     // Determine list of available components in S2 from index.ts
     let availableComponents = new Set();
-    const packagePath = require.resolve('@react-spectrum/s2');
-    const indexPath = path.join(path.dirname(packagePath), process.env.NODE_ENV === 'test' ? 'src/index.ts' : '../src/index.ts');
+    let indexPath;
+    try {
+        const packagePath = require.resolve('@react-spectrum/s2');
+        indexPath = path.join(path.dirname(packagePath), process.env.NODE_ENV === 'test' ? 'index.ts' : '../../exports/index.ts');
+    }
+    catch {
+        const workspaceIndexPath = path.resolve(__dirname, '../../../../../@react-spectrum/s2/exports/index.ts');
+        if (!(0, fs_1.existsSync)(workspaceIndexPath)) {
+            throw new Error('Could not resolve @react-spectrum/s2 source for codemods.');
+        }
+        indexPath = workspaceIndexPath;
+    }
     let index = (0, parser_1.parse)((0, fs_1.readFileSync)(indexPath, 'utf8'), { sourceType: 'module', plugins: ['typescript'] });
     (0, traverse_1.default)(index, {
         ExportNamedDeclaration(path) {

package/dist/s1-to-s2/src/index.js

@@ -11,7 +11,24 @@ const logger_js_1 = __importDefault(require("./utils/logger.js"));
 const transform_js_1 = require("./transform.js");
 const waitForKeypress_js_1 = require("./utils/waitForKeypress.js");
 const boxen = require('boxen');
+function printNextSteps(nextSteps) {
+    console.log(boxen(`Next steps:\n\n ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join('\n\n\n')}`, { borderStyle: 'round', padding: 1, borderColor: 'green' }));
+}
 async function s1_to_s2(options) {
+    if (options.agent) {
+        logger_js_1.default.info('Running s1-to-s2 in agent mode (non-interactive, transform-only).');
+        logger_js_1.default.info('Upgrading components...');
+        await (0, transform_js_1.transform)(options);
+        logger_js_1.default.success('Upgrade complete!');
+        printNextSteps([
+            `Ensure ${chalk_1.default.bold('@react-spectrum/s2')} is installed.`,
+            `If your bundler is not Parcel v2.12.0+, configure the Spectrum 2 style macro support. See: ${chalk_1.default.underline('https://react-spectrum.adobe.com/getting-started#framework-setup')}`,
+            `Add ${chalk_1.default.bold('import \'@react-spectrum/s2/page.css\';')} to your entry component if needed.`,
+            `Search for ${chalk_1.default.bold('TODO(S2-upgrade)')} and resolve remaining manual migration updates.`,
+            `Reference the migration guide: ${chalk_1.default.underline('https://react-spectrum.adobe.com/migrating')}`
+        ]);
+        return;
+    }
     console.log(boxen('Welcome to the React Spectrum v3 to Spectrum 2 upgrade assistant!\n\n' +
         'This tool will:\n\n' +
         `1. Install the ${chalk_1.default.bold('@react-spectrum/s2')} package and setup your bundler to use the Spectrum 2 style macro.\n\n` +
@@ -44,14 +61,14 @@ async function s1_to_s2(options) {
             `  - Vite: ${chalk_1.default.underline('https://github.com/adobe/react-spectrum/tree/main/examples/s2-vite-project')}\n` +
             `  - Rollup: ${chalk_1.default.underline('https://github.com/adobe/react-spectrum/tree/main/examples/s2-rollup-starter-app')}\n` +
             `  - ESBuild: ${chalk_1.default.underline('https://github.com/adobe/react-spectrum/tree/main/examples/s2-esbuild-starter-app')}\n\n` +
-            `or view documentation here: ${chalk_1.default.underline('https://react-spectrum.adobe.com/s2/index.html?path=/docs/intro--docs#configuring-your-bundler')}`);
+            `or view documentation here: ${chalk_1.default.underline('https://react-spectrum.adobe.com/getting-started#framework-setup')}`);
     }
     nextSteps.push('Handle remaining upgrades and run your project\'s linter or formatter.\n\n' +
         'There may have been some upgrades that we couldn\'t handle automatically. We marked these with comments containing:\n\n' +
         `${chalk_1.default.bold('TODO(S2-upgrade)')}\n\n` +
         'You should be able to search your codebase and handle these manually. \n\n' +
         'We also recommend running your project\'s code formatter (i.e. Prettier, ESLint) after the upgrade process to clean up any extraneous formatting from the codemod.\n\n' +
-        `For additional help, reference the Spectrum 2 Migration Guide: ${chalk_1.default.underline('https://react-spectrum.adobe.com/s2/index.html?path=/docs/migrating--docs')}`);
-    console.log(boxen(`Next steps:\n\n ${nextSteps.map((step, i) => `${i + 1}. ${step}`).join('\n\n\n')}`, { borderStyle: 'round', padding: 1, borderColor: 'green' }));
+        `For additional help, reference the Spectrum 2 Migration Guide: ${chalk_1.default.underline('https://react-spectrum.adobe.com/migrating')}`);
+    printNextSteps(nextSteps);
     process.exit(0);
 }

package/dist/s1-to-s2/src/transform.js

@@ -8,6 +8,7 @@ const Runner_js_1 = require("jscodeshift/src/Runner.js");
 const path_1 = __importDefault(require("path"));
 const transformPath = path_1.default.join(__dirname, 'codemods', 'codemod.js');
 async function transform(options) {
-    let { path: filePath = '.', ...rest } = options;
-    return await (0, Runner_js_1.run)(transformPath, [filePath], rest);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { path: filePath = '.', agent, ...jscodeshiftOptions } = options;
+    return await (0, Runner_js_1.run)(transformPath, [filePath], jscodeshiftOptions);
 }

package/dist/use-monopackages/src/codemod.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require('fs');
 const path = require('path');
+const Module = require('module');
+const url = require('url');
 function areSpecifiersAlphabetized(specifiers) {
     const specifierNames = specifiers.map((specifier) => specifier.imported.name);
     const sortedNames = [...specifierNames].sort();
@@ -41,7 +43,17 @@ const transformer = function transformer(file, api, options) {
     let anyIndexFound = false;
     const monopackageExports = {};
     selectedPackages.forEach((pkg) => {
-        const indexPath = path.join(process.cwd(), `node_modules/${packages[pkg].monopackage}/dist/types.d.ts`);
+        let indexPath;
+        try {
+            let pkgPath = path.dirname(Module.findPackageJSON(packages[pkg].monopackage, url.pathToFileURL(file.path || `${process.cwd()}/index`)));
+            indexPath = `${pkgPath}/dist/types/exports/index.d.ts`;
+            if (!fs.existsSync(indexPath)) {
+                indexPath = `${pkgPath}/exports/index.ts`;
+            }
+        }
+        catch {
+            return;
+        }
         if (fs.existsSync(indexPath)) {
             anyIndexFound = true;
             const indexFile = fs.readFileSync(indexPath, 'utf8');
@@ -79,7 +91,7 @@ const transformer = function transformer(file, api, options) {
         const individualPackageImports = root
             .find(j.ImportDeclaration)
             .filter((path) => {
-            return path.node.source.value?.startsWith(packages[pkg].individualPrefix);
+            return path.node.source.value !== '@react-spectrum/s2' && path.node.source.value?.startsWith(packages[pkg].individualPrefix);
         });
         if (individualPackageImports.size() === 0) {
             return;

package/dist/use-subpaths/src/codemod.js

@@ -0,0 +1,201 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const specifiers_1 = require("./specifiers");
+const parser_1 = require("@babel/parser");
+const recast_1 = require("recast");
+const t = __importStar(require("@babel/types"));
+function getImportedName(specifier) {
+    return specifier.imported.type === 'Identifier' ? specifier.imported.name : specifier.imported.value;
+}
+function getImportKey(specifier) {
+    const importedName = getImportedName(specifier);
+    const localName = specifier.local?.name ?? importedName;
+    const importKind = specifier.importKind ?? 'value';
+    return `${importKind}:${importedName}:${localName}`;
+}
+function getImportDeclarationKey(node) {
+    return (node.importKind ?? 'value') + ':' + node.source.value;
+}
+function getNamedSpecifierKeys(importDeclaration) {
+    let keys = new Set();
+    for (let specifier of importDeclaration.specifiers ?? []) {
+        if (specifier.type === 'ImportSpecifier') {
+            keys.add(getImportKey(specifier));
+        }
+    }
+    return keys;
+}
+function createImportDeclaration(source, importKind, specifiers) {
+    let declaration = t.importDeclaration(specifiers, t.stringLiteral(source));
+    declaration.importKind = importKind ?? 'value';
+    return declaration;
+}
+function resolveTargetSource(candidates, uniqueSources, existingImports) {
+    // Group with the first unique source that contained a candidate.
+    // For example if you imported ListBox, ActionGroup, and Item, Item would be grouped with ListBox.
+    for (let source of uniqueSources) {
+        if (candidates.includes(source)) {
+            return source;
+        }
+    }
+    // Group with an already existing import.
+    for (let source of existingImports.keys()) {
+        if (candidates.includes(source)) {
+            return source;
+        }
+    }
+    return candidates[0];
+}
+function transformer(file, api) {
+    let specifiersByPackage = (0, specifiers_1.getSpecifiersByPackage)(file.path);
+    let j = api.jscodeshift.withParser({
+        parse(source) {
+            return (0, recast_1.parse)(source, {
+                parser: {
+                    parse(innerSource) {
+                        return (0, parser_1.parse)(innerSource, {
+                            sourceType: 'module',
+                            plugins: [
+                                'jsx',
+                                'typescript',
+                                'importAssertions',
+                                'dynamicImport',
+                                'decorators-legacy',
+                                'classProperties',
+                                'classPrivateProperties',
+                                'classPrivateMethods',
+                                'exportDefaultFrom',
+                                'exportNamespaceFrom',
+                                'objectRestSpread',
+                                'optionalChaining',
+                                'nullishCoalescingOperator',
+                                'topLevelAwait'
+                            ],
+                            tokens: true,
+                            errorRecovery: true
+                        });
+                    }
+                }
+            });
+        }
+    });
+    let root = j(file.source);
+    let program = root.get().node.program;
+    let uniqueSources = new Set();
+    let existingImports = new Map();
+    for (let node of program.body) {
+        if (node.type === 'ImportDeclaration') {
+            let source = node.source.value;
+            if (typeof source !== 'string') {
+                continue;
+            }
+            existingImports.set(getImportDeclarationKey(node), node);
+            if (source in specifiersByPackage) {
+                let sourceMap = specifiersByPackage[source];
+                for (let specifier of node.specifiers ?? []) {
+                    if (specifier.type !== 'ImportSpecifier') {
+                        continue;
+                    }
+                    let importedName = getImportedName(specifier);
+                    let candidates = sourceMap[importedName];
+                    if (candidates && (candidates.length === 1 || candidates[0] === `${source}/${importedName}`)) {
+                        let importKind = node.importKind || 'value';
+                        uniqueSources.add(importKind + ':' + candidates[0]);
+                    }
+                }
+            }
+        }
+    }
+    let didChange = false;
+    program.body = program.body.flatMap(node => {
+        if (node.type !== 'ImportDeclaration') {
+            return [node];
+        }
+        let source = node.source.value;
+        if (typeof source !== 'string' || !(source in specifiersByPackage)) {
+            return [node];
+        }
+        let importDeclaration = node;
+        let sourceMap = specifiersByPackage[node.source.value];
+        let movedSpecifiersBySource = new Map();
+        importDeclaration.specifiers = importDeclaration.specifiers.filter(specifier => {
+            if (specifier.type !== 'ImportSpecifier') {
+                return true;
+            }
+            let importedName = getImportedName(specifier);
+            let candidates = sourceMap[importedName];
+            if (!candidates || candidates.length === 0) {
+                return true;
+            }
+            let importKind = node.importKind || 'value';
+            let targetSource = candidates.length === 1
+                ? importKind + ':' + candidates[0]
+                : resolveTargetSource(candidates.map(c => importKind + ':' + c), uniqueSources, existingImports);
+            let movedSpecifiers = movedSpecifiersBySource.get(targetSource) ?? [];
+            movedSpecifiers.push(t.cloneNode(specifier, true));
+            movedSpecifiersBySource.set(targetSource, movedSpecifiers);
+            didChange = true;
+            return false;
+        });
+        if (movedSpecifiersBySource.size === 0) {
+            return [node];
+        }
+        let newDeclarations = [];
+        if (importDeclaration.specifiers.length > 0) {
+            newDeclarations.push(node);
+        }
+        for (let [targetSource, movedSpecifiers] of movedSpecifiersBySource) {
+            let destinationImport = existingImports.get(targetSource);
+            if (!destinationImport) {
+                destinationImport = createImportDeclaration(targetSource.slice(targetSource.indexOf(':') + 1), importDeclaration.importKind, []);
+                newDeclarations.push(destinationImport);
+                existingImports.set(targetSource, destinationImport);
+            }
+            let existingSpecifierKeys = getNamedSpecifierKeys(destinationImport);
+            for (let movedSpecifier of movedSpecifiers) {
+                let key = getImportKey(movedSpecifier);
+                if (!existingSpecifierKeys.has(key)) {
+                    destinationImport.specifiers.push(movedSpecifier);
+                    existingSpecifierKeys.add(key);
+                }
+            }
+        }
+        return newDeclarations;
+    });
+    return didChange ? root.toSource({ quote: 'single' }) : file.source;
+}
+;

package/dist/use-subpaths/src/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.use_subpaths = use_subpaths;
+const Runner_js_1 = require("jscodeshift/src/Runner.js");
+const path_1 = __importDefault(require("path"));
+const transformPath = path_1.default.join(__dirname, 'codemod.js');
+async function use_subpaths(options) {
+    let { path: filePath = '.', ...rest } = options;
+    return await (0, Runner_js_1.run)(transformPath, [filePath], rest);
+}

package/dist/use-subpaths/src/specifiers.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecifiersByPackage = getSpecifiersByPackage;
+/* eslint-disable max-depth */
+const fs_1 = __importDefault(require("fs"));
+const module_1 = __importDefault(require("module"));
+const parser_1 = require("@babel/parser");
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+const PACKAGES = [
+    '@adobe/react-spectrum',
+    '@react-spectrum/s2',
+    'react-aria-components',
+    'react-aria',
+    'react-stately'
+];
+const specifiersByPackage = {};
+/** Builds a mapping of monopackage -> export -> subpaths that contain the export. */
+function getSpecifiersByPackage(from) {
+    for (let pkg of PACKAGES) {
+        if (specifiersByPackage[pkg]) {
+            continue;
+        }
+        let dir;
+        try {
+            let pkgPath = path_1.default.dirname(module_1.default.findPackageJSON(pkg, url_1.default.pathToFileURL(from || `${process.cwd()}/index`)));
+            dir = `${pkgPath}/dist/types/exports`;
+            if (!fs_1.default.existsSync(dir)) {
+                dir = `${pkgPath}/exports`;
+            }
+            if (!fs_1.default.existsSync(dir)) {
+                continue;
+            }
+        }
+        catch {
+            continue;
+        }
+        let exports = {};
+        for (let entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name === 'index.ts' || entry.name === 'index.d.ts' || !entry.isFile()) {
+                continue;
+            }
+            let contents = fs_1.default.readFileSync(`${dir}/${entry.name}`, 'utf8');
+            let ast = (0, parser_1.parse)(contents, {
+                sourceType: 'module',
+                plugins: ['typescript']
+            });
+            let subpath = entry.name.replace(/(\.d)?\.ts$/, '');
+            let importSpecifier = `${pkg}/${subpath}`;
+            for (let node of ast.program.body) {
+                if (node.type === 'ExportNamedDeclaration') {
+                    for (let specifier of node.specifiers) {
+                        if (specifier.type !== 'ExportSpecifier') {
+                            continue;
+                        }
+                        let exported = specifier.exported.type === 'Identifier' ? specifier.exported.name : specifier.exported.value;
+                        exports[exported] ?? (exports[exported] = []);
+                        if (exported.startsWith(subpath)) {
+                            exports[exported].unshift(importSpecifier);
+                        }
+                        else {
+                            exports[exported].push(importSpecifier);
+                        }
+                    }
+                }
+            }
+            specifiersByPackage[pkg] = exports;
+        }
+    }
+    return specifiersByPackage;
+}