@react-spectrum/codemods 1.1.0 → 1.2.0

package/dist/index.js

@@ -4,9 +4,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const { parseArgs } = require('node:util');
 const src_1 = require("./s1-to-s2/src");
 const src_2 = require("./use-monopackages/src");
+const src_3 = require("./use-subpaths/src");
 const codemods = {
     's1-to-s2': src_1.s1_to_s2,
-    'use-monopackages': src_2.use_monopackages
+    'use-monopackages': src_2.use_monopackages,
+    'use-subpaths': src_3.use_subpaths
 };
 // https://github.com/facebook/jscodeshift?tab=readme-ov-file#usage-cli
 const options = {
@@ -25,6 +27,9 @@ const options = {
     },
     'components': {
         type: 'string'
+    },
+    'agent': {
+        type: 'boolean'
     }
 };
 const { values, positionals } = parseArgs({
@@ -35,21 +40,22 @@ if (positionals.length < 1) {
     console.error('Please specify a codemod to run. Available codemods: ', Object.keys(codemods).join(', '));
     process.exit(1);
 }
-const codemodName = positionals[0];
-const codemodFunction = codemods[codemodName];
-if (!codemodFunction) {
-    console.error(`Unknown codemod: ${codemodName}, available codemods: ${Object.keys(codemods).join(', ')}`);
-    process.exit(1);
-}
-try {
-    codemodFunction({
+async function main() {
+    const codemodName = positionals[0];
+    const codemodFunction = codemods[codemodName];
+    if (!codemodFunction) {
+        console.error(`Unknown codemod: ${codemodName}, available codemods: ${Object.keys(codemods).join(', ')}`);
+        process.exit(1);
+    }
+    await Promise.resolve(codemodFunction({
         parser: 'tsx',
         ignorePattern: '**/node_modules/**',
         path: '.',
+        extensions: 'js,jsx,mjs,cjs,ts,tsx',
         ...values
-    });
+    }));
 }
-catch (error) {
+main().catch((error) => {
     console.error(`Error running codemod: ${error}`);
     process.exit(1);
-}
+});

package/dist/s1-to-s2/src/codemods/codemod.js

@@ -41,6 +41,7 @@ exports.default = transformer;
 const utils_1 = require("./shared/utils");
 const getComponents_1 = require("../getComponents");
 const iconMap_1 = require("./icons/iconMap");
+const illustrationMap_1 = require("./illustrations/illustrationMap");
 const recast_1 = require("recast");
 const t = __importStar(require("@babel/types"));
 const styleProps_1 = __importDefault(require("./shared/styleProps"));
@@ -63,6 +64,108 @@ availableComponents.add('ActionGroup');
 let renamedComponents = {
     ContextualHelpTrigger: 'UnavailableMenuItemTrigger'
 };
+const relatedComponentGroups = {
+    ActionMenu: {
+        scopedComponents: {
+            Item: ['ActionMenu']
+        }
+    },
+    Breadcrumbs: {
+        scopedComponents: {
+            Item: ['Breadcrumbs']
+        }
+    },
+    ComboBox: {
+        scopedComponents: {
+            Item: ['ComboBox'],
+            Section: ['ComboBox']
+        }
+    },
+    DialogContainer: {
+        components: ['Dialog']
+    },
+    DialogTrigger: {
+        components: ['Dialog']
+    },
+    Menu: {
+        components: ['ContextualHelpTrigger', 'MenuTrigger', 'SubmenuTrigger'],
+        scopedComponents: {
+            Item: ['Menu'],
+            Section: ['Menu']
+        }
+    },
+    Picker: {
+        scopedComponents: {
+            Item: ['Picker'],
+            Section: ['Picker']
+        }
+    },
+    TableView: {
+        components: ['Cell', 'Column', 'Row', 'TableBody', 'TableHeader']
+    },
+    Tabs: {
+        components: ['TabList', 'TabPanels']
+    },
+    TagGroup: {
+        scopedComponents: {
+            Item: ['TagGroup']
+        }
+    },
+    TooltipTrigger: {
+        components: ['Tooltip']
+    }
+};
+function addScopedParents(scopedComponents, component, parents) {
+    let existingParents = scopedComponents.get(component) ?? new Set();
+    for (let parent of parents) {
+        existingParents.add(parent);
+    }
+    scopedComponents.set(component, existingParents);
+}
+function getComponentSelection(components) {
+    if (!components) {
+        return {
+            components: new Set(availableComponents),
+            explicitComponents: new Set(availableComponents),
+            scopedComponents: new Map()
+        };
+    }
+    let explicitComponents = new Set(components.split(',').map(s => s.trim()).filter(Boolean));
+    let expandedComponents = new Set(explicitComponents);
+    let scopedComponents = new Map();
+    for (let component of explicitComponents) {
+        let relatedComponents = relatedComponentGroups[component];
+        if (!relatedComponents) {
+            continue;
+        }
+        for (let relatedComponent of relatedComponents.components ?? []) {
+            expandedComponents.add(relatedComponent);
+        }
+        for (let [relatedComponent, parents] of Object.entries(relatedComponents.scopedComponents ?? {})) {
+            expandedComponents.add(relatedComponent);
+            if (!explicitComponents.has(relatedComponent)) {
+                addScopedParents(scopedComponents, relatedComponent, parents);
+            }
+        }
+    }
+    return {
+        components: new Set([...expandedComponents].filter(component => availableComponents.has(component))),
+        explicitComponents: new Set([...explicitComponents].filter(component => availableComponents.has(component))),
+        scopedComponents
+    };
+}
+function shouldTransformElement(componentName, path, selection) {
+    if (selection.explicitComponents.has(componentName)) {
+        return true;
+    }
+    let allowedParents = selection.scopedComponents.get(componentName);
+    if (!allowedParents || allowedParents.size === 0) {
+        return true;
+    }
+    return !!path.findParent((parentPath) => t.isJSXElement(parentPath.node)
+        && t.isJSXIdentifier(parentPath.node.openingElement.name)
+        && allowedParents.has((0, utils_1.getName)(path, parentPath.node.openingElement.name)));
+}
 function transformer(file, api, options) {
     let j = api.jscodeshift.withParser({
         parse(source) {
@@ -72,7 +175,8 @@ function transformer(file, api, options) {
         }
     });
     let root = j(file.source);
-    let componentsToTransform = options.components ? new Set(options.components.split(',').filter(s => availableComponents.has(s))) : availableComponents;
+    let selection = getComponentSelection(options.components);
+    let componentsToTransform = selection.components;
     let v3ComponentsToRename = new Set(Object.keys(renamedComponents));
     let S2ComponentsToImport = new Set();
     let bindings = [];
@@ -80,8 +184,13 @@ function transformer(file, api, options) {
     let elements = [];
     let lastImportPath = null;
     let iconImports = new Map();
+    let illustrationImports = new Map();
+    let programPath = null;
     const leadingComments = root.find(j.Program).get('body', 0).node.leadingComments;
     (0, traverse_1.default)(root.paths()[0].node, {
+        Program(path) {
+            programPath = path;
+        },
         ImportDeclaration(path) {
             if (path.node.source.value === '@adobe/react-spectrum' || (path.node.source.value.startsWith('@react-spectrum/') && path.node.source.value !== '@react-spectrum/s2')) {
                 lastImportPath = path;
@@ -97,7 +206,10 @@ function transformer(file, api, options) {
                                 if (propName && path.parentPath.parentPath?.parentPath?.isJSXElement()) {
                                     if (componentsToTransform.has(propName)) {
                                         importedComponents.set(propName, clonedSpecifier);
-                                        elements.push([propName, path.parentPath.parentPath.parentPath]);
+                                        let elementPath = path.parentPath.parentPath.parentPath;
+                                        if (shouldTransformElement(propName, elementPath, selection)) {
+                                            elements.push([propName, elementPath]);
+                                        }
                                     }
                                     else if (v3ComponentsToRename.has(propName)) {
                                         S2ComponentsToImport.add(renamedComponents[propName]);
@@ -141,7 +253,10 @@ function transformer(file, api, options) {
                             bindings.push(binding);
                             for (let path of binding.referencePaths) {
                                 if (path.parentPath?.isJSXOpeningElement() && path.parentPath.parentPath.isJSXElement()) {
-                                    elements.push([specifier.imported.name, path.parentPath.parentPath]);
+                                    let elementPath = path.parentPath.parentPath;
+                                    if (shouldTransformElement(specifier.imported.name, elementPath, selection)) {
+                                        elements.push([specifier.imported.name, elementPath]);
+                                    }
                                 }
                             }
                         }
@@ -167,6 +282,24 @@ function transformer(file, api, options) {
                     iconImports.set(localName, { path, newName: null });
                 }
             }
+            else if (path.node.source.value.startsWith('@spectrum-icons/illustrations/')) {
+                let illustrationName = path.node.source.value.split('/').pop();
+                if (!illustrationName) {
+                    return;
+                }
+                let specifier = path.node.specifiers[0];
+                if (!specifier || !t.isImportDefaultSpecifier(specifier)) {
+                    return;
+                }
+                let localName = specifier.local.name;
+                if (illustrationMap_1.illustrationMap.has(illustrationName)) {
+                    let newIllustrationName = illustrationMap_1.illustrationMap.get(illustrationName);
+                    illustrationImports.set(localName, { path, newName: newIllustrationName });
+                }
+                else {
+                    illustrationImports.set(localName, { path, newName: null });
+                }
+            }
         },
         Import(path) {
             let call = path.parentPath;
@@ -177,7 +310,9 @@ function transformer(file, api, options) {
             if (arg.type !== 'StringLiteral') {
                 return;
             }
-            if (arg.value !== '@adobe/react-spectrum' && !arg.value.startsWith('@react-spectrum/')) {
+            let isV3ImportSource = arg.value === '@adobe/react-spectrum'
+                || (arg.value.startsWith('@react-spectrum/') && arg.value !== '@react-spectrum/s2');
+            if (!isV3ImportSource) {
                 return;
             }
             // TODO: implement this. could be a bit challenging. punting for now.
@@ -191,6 +326,12 @@ function transformer(file, api, options) {
                     (0, utils_1.addComment)(path.node, ` TODO(S2-upgrade): A Spectrum 2 equivalent to '${name.name}' was not found. Please update this icon manually.`);
                 }
             }
+            if (t.isJSXIdentifier(name) && illustrationImports.has(name.name)) {
+                let illustrationInfo = illustrationImports.get(name.name);
+                if (illustrationInfo.newName === null) {
+                    (0, utils_1.addComment)(path.node, ` TODO(S2-upgrade): A Spectrum 2 equivalent to '${name.name}' was not found. Please update this illustration manually.`);
+                }
+            }
         }
     });
     iconImports.forEach((iconInfo, localName) => {
@@ -216,6 +357,26 @@ function transformer(file, api, options) {
             path.node.specifiers = [t.importDefaultSpecifier(t.identifier(newLocalName))];
         }
     });
+    illustrationImports.forEach((illustrationInfo, localName) => {
+        let { path, newName } = illustrationInfo;
+        if (newName) {
+            let newImportSource = `@react-spectrum/s2/illustrations/linear/${newName}`;
+            let newLocalName = localName;
+            if (localName === path.node.source.value.split('/').pop() && localName !== newName) {
+                let binding = path.scope.getBinding(localName);
+                if (binding && !path.scope.hasBinding(newName)) {
+                    newLocalName = newName;
+                    binding.referencePaths.forEach(refPath => {
+                        if (t.isJSXIdentifier(refPath.node)) {
+                            refPath.node.name = newName;
+                        }
+                    });
+                }
+            }
+            path.node.source = t.stringLiteral(newImportSource);
+            path.node.specifiers = [t.importDefaultSpecifier(t.identifier(newLocalName))];
+        }
+    });
     let hasMacros = false;
     let usedLightDark = false;
     elements.forEach(([elementName, path]) => {
@@ -268,16 +429,24 @@ function transformer(file, api, options) {
         });
         if (existingImport.length) {
             let importDecl = existingImport.get();
-            for (let specifier of importDecl.node.specifiers) {
-                if (specifier.type === 'ImportSpecifier'
-                    && importedComponents.has(specifier.imported.name)) {
-                    importSpecifiers.add(specifier);
-                }
-            }
+            let existingSpecifiers = importDecl.value.specifiers;
             // add importSpecifiers to existing import
             importDecl.value.specifiers = [...importDecl.value.specifiers, ...[...importSpecifiers].filter(specifier => {
-                    // @ts-ignore
-                    return specifier.imported.name !== 'Item' && ![...importDecl.value.specifiers].find(s => s.imported.name === specifier.imported.name);
+                    if (t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported)) {
+                        if (specifier.imported.name === 'Item') {
+                            return false;
+                        }
+                        let importedName = specifier.imported.name;
+                        let localName = specifier.local?.name || importedName;
+                        return !existingSpecifiers.find((s) => t.isImportSpecifier(s)
+                            && t.isIdentifier(s.imported)
+                            && s.imported.name === importedName
+                            && (s.local?.name || s.imported.name) === localName);
+                    }
+                    if (t.isImportNamespaceSpecifier(specifier)) {
+                        return !existingSpecifiers.find((s) => t.isImportNamespaceSpecifier(s) && s.local.name === specifier.local.name);
+                    }
+                    return false;
                 })];
         }
         else {
@@ -305,6 +474,9 @@ function transformer(file, api, options) {
             }
         });
     }
+    if (programPath) {
+        (0, utils_1.removeUnusedImports)(programPath, ['@react-spectrum/s2']);
+    }
     root.find(j.Program).get('body', 0).node.comments = leadingComments;
     return root.toSource().replace(/assert\s*\{\s*type:\s*"macro"\s*\}/g, 'with { type: "macro" }');
 }

package/dist/s1-to-s2/src/codemods/components/ActionGroup/transform.js

@@ -51,6 +51,7 @@ let availableComponents = (0, getComponents_1.getComponents)();
  * - Convert dynamic collections render function to items.map.
  */
 function transformActionGroup(path) {
+    let program = path.findParent((p) => t.isProgram(p.node));
     // Comment out overflowMode
     (0, transforms_1.commentOutProp)(path, { propName: 'overflowMode' });
     // Comment out buttonLabelBehavior
@@ -73,12 +74,10 @@ function transformActionGroup(path) {
     }
     let localName = newComponentName;
     if (availableComponents.has(newComponentName)) {
-        let program = path.findParent((p) => t.isProgram(p.node));
         localName = (0, utils_1.addComponentImport)(program, newComponentName);
     }
     let localChildName = childComponentName;
     if (availableComponents.has(childComponentName)) {
-        let program = path.findParent((p) => t.isProgram(p.node));
         localChildName = (0, utils_1.addComponentImport)(program, childComponentName);
     }
     // Convert dynamic collection to an array.map.
@@ -161,4 +160,5 @@ function transformActionGroup(path) {
     if (path.node.closingElement) {
         path.node.closingElement.name = t.jsxIdentifier(localName);
     }
+    (0, utils_1.removeComponentImportIfUnused)(program, 'Item');
 }

package/dist/s1-to-s2/src/codemods/components/ActionMenu/transform.js

@@ -4,12 +4,12 @@ exports.default = transformActionMenu;
 const transforms_1 = require("../../shared/transforms");
 /**
  * Transforms ActionMenu:
- * - Comment out closeOnSelect (it has not been implemented yet).
+ * - Rename `closeOnSelect` to `shouldCloseOnSelect`.
  * - Comment out trigger (it has not been implemented yet).
  */
 function transformActionMenu(path) {
-    // Comment out closeOnSelect
-    (0, transforms_1.commentOutProp)(path, { propName: 'closeOnSelect' });
+    // Rename `closeOnSelect` to `shouldCloseOnSelect`
+    (0, transforms_1.updatePropName)(path, { oldPropName: 'closeOnSelect', newPropName: 'shouldCloseOnSelect' });
     // Comment out trigger
     (0, transforms_1.commentOutProp)(path, { propName: 'trigger' });
 }

package/dist/s1-to-s2/src/codemods/components/ContextualHelpTrigger/transform.js

@@ -65,4 +65,5 @@ function transformContextualHelpTrigger(path) {
             }
         }
     }
+    (0, utils_1.removeComponentImportIfUnused)(program, 'Dialog');
 }

package/dist/s1-to-s2/src/codemods/components/DialogTrigger/transform.js

@@ -49,6 +49,7 @@ let availableComponents = (0, getComponents_1.getComponents)();
  * - When `type="fullscreenTakeover"`, replaces Dialog with `<FullscreenDialog variant="fullscreenTakeover">`.
  */
 function updateDialogChild(path) {
+    let program = path.findParent((p) => t.isProgram(p.node));
     let typePath = path.get('openingElement').get('attributes').find((attr) => t.isJSXAttribute(attr.node) && attr.node.name.name === 'type');
     let type = typePath?.node.value?.type === 'StringLiteral' ? typePath.node.value?.value : 'modal';
     let newComponentName = 'Dialog';
@@ -72,7 +73,6 @@ function updateDialogChild(path) {
     typePath?.remove();
     let localName = newComponentName;
     if (newComponentName !== 'Dialog' && availableComponents.has(newComponentName)) {
-        let program = path.findParent((p) => t.isProgram(p.node));
         localName = (0, utils_1.addComponentImport)(program, newComponentName);
     }
     path.traverse({
@@ -87,6 +87,20 @@ function updateDialogChild(path) {
             dialog.node.openingElement.attributes.push(...props);
         }
     });
+    path.traverse({
+        JSXElement(childPath) {
+            if (t.isJSXIdentifier(childPath.node.openingElement.name)
+                && (0, utils_1.getName)(childPath, childPath.node.openingElement.name) === 'Divider'
+                && t.isJSXElement(childPath.parentPath.node)
+                && t.isJSXIdentifier(childPath.parentPath.node.openingElement.name)) {
+                let parentName = (0, utils_1.getName)(childPath, childPath.parentPath.node.openingElement.name);
+                if (parentName === 'Dialog' || parentName === 'Popover' || parentName === 'FullscreenDialog') {
+                    childPath.remove();
+                }
+            }
+        }
+    });
+    (0, utils_1.removeComponentImportIfUnused)(program, 'Divider');
 }
 /**
  * Transforms DialogTrigger:

package/dist/s1-to-s2/src/codemods/components/MenuTrigger/transform.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformMenuTrigger;
+const transforms_1 = require("../../shared/transforms");
+/**
+ * Transforms MenuTrigger:
+ * - Rename `closeOnSelect` to `shouldCloseOnSelect` and move it to the child `Menu`.
+ */
+function transformMenuTrigger(path) {
+    (0, transforms_1.updatePropName)(path, { oldPropName: 'closeOnSelect', newPropName: 'shouldCloseOnSelect' });
+    (0, transforms_1.movePropToChildComponent)(path, {
+        parentComponentName: 'MenuTrigger',
+        childComponentName: 'Menu',
+        propName: 'shouldCloseOnSelect'
+    });
+}

package/dist/s1-to-s2/src/codemods/components/Picker/transform.js

@@ -9,6 +9,9 @@ const transforms_1 = require("../../shared/transforms");
  * - Change validationState="invalid" to isInvalid.
  * - Remove validationState="valid" (it is no longer supported in Spectrum 2).
  * - Replace isLoading with loadingState.
+ * - Rename onSelectionChange to onChange.
+ * - Rename selectedKey to value.
+ * - Rename defaultSelectedKey to defaultValue.
  */
 function transformPicker(path) {
     // Change menuWidth value from a DimensionValue to a pixel value
@@ -30,4 +33,19 @@ function transformPicker(path) {
         newPropName: 'loadingState',
         comment: 'Replace boolean passed to isLoading with appropriate loadingState.'
     });
+    // Rename onSelectionChange to onChange
+    (0, transforms_1.updatePropName)(path, {
+        oldPropName: 'onSelectionChange',
+        newPropName: 'onChange'
+    });
+    // Rename selectedKey to value
+    (0, transforms_1.updatePropName)(path, {
+        oldPropName: 'selectedKey',
+        newPropName: 'value'
+    });
+    // Rename defaultSelectedKey to defaultValue
+    (0, transforms_1.updatePropName)(path, {
+        oldPropName: 'defaultSelectedKey',
+        newPropName: 'defaultValue'
+    });
 }

package/dist/s1-to-s2/src/codemods/components/Tabs/transform.js

@@ -38,11 +38,12 @@ const utils_1 = require("../../shared/utils");
 const transforms_1 = require("../../shared/transforms");
 const t = __importStar(require("@babel/types"));
 function transformTabList(tabListPath) {
-    tabListPath.get('children').forEach(itemPath => {
-        if (t.isJSXElement(itemPath.node) &&
-            t.isJSXIdentifier(itemPath.node.openingElement.name) &&
-            (0, utils_1.getName)(itemPath, itemPath.node.openingElement.name) === 'Item') {
-            (0, transforms_1.updateComponentWithinCollection)(itemPath, { parentComponentName: 'TabList', newComponentName: 'Tab' });
+    tabListPath.traverse({
+        JSXElement(itemPath) {
+            if (t.isJSXIdentifier(itemPath.node.openingElement.name) &&
+                (0, utils_1.getName)(itemPath, itemPath.node.openingElement.name) === 'Item') {
+                (0, transforms_1.updateComponentWithinCollection)(itemPath, { parentComponentName: 'TabList', newComponentName: 'Tab' });
+            }
         }
     });
     return tabListPath.node;
@@ -113,4 +114,5 @@ function transformTabs(path) {
     (0, transforms_1.removeProp)(path, { propName: 'isEmphasized' });
     // Remove isQuiet
     (0, transforms_1.removeProp)(path, { propName: 'isQuiet' });
+    (0, utils_1.removeComponentImportIfUnused)(program, 'Item');
 }

package/dist/s1-to-s2/src/codemods/illustrations/illustrationMap.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.illustrationMap = void 0;
+exports.illustrationMap = new Map([
+    ['Error', 'Error'],
+    ['File', 'Document'],
+    ['Folder', 'FolderClose'],
+    ['NoSearchResults', 'NoSearchResults'],
+    ['NotFound', 'NoSearchResults'],
+    ['Timeout', 'Clock'],
+    ['Unauthorized', 'LockClose'],
+    ['Unavailable', 'Error'],
+    ['Upload', 'Upload']
+]);

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;
@@ -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;
+}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@react-spectrum/codemods",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "main": "dist/index.js",
   "source": "src/index.ts",
   "bin": "dist/index.js",
   "targets": {
     "main": false
   },
+  "engines": {
+    "node": ">=22.14.0"
+  },
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "yarn build"
@@ -21,11 +24,12 @@
     "url": "https://github.com/adobe/react-spectrum"
   },
   "dependencies": {
+    "@adobe/react-spectrum": "3.47.0",
     "@babel/parser": "^7.24.5",
     "@babel/traverse": "^7.24.5",
     "@babel/types": "^7.24.5",
-    "@react-spectrum/s2": "^1.2.0",
-    "@react-types/shared": "^3.33.1",
+    "@react-spectrum/s2": "1.3.0",
+    "@react-types/shared": "^3.34.0",
     "@types/node": "^24",
     "boxen": "^5.1.2",
     "chalk": "^4.0.0",
@@ -49,5 +53,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8df187370053aa35f553cb388ad670f65e1ab371"
+  "gitHead": "a6999bdf494a2e9c0381a5881908328bdd22ddae"
 }