@react-spectrum/codemods 0.1.0

package/dist/s1-to-s2/src/utils/addMacroSupport.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMacroSupport = addMacroSupport;
+const path = require('path');
+const installPackage_1 = __importDefault(require("./installPackage"));
+const logger_1 = __importDefault(require("./logger"));
+async function addMacroSupport() {
+    const packageJson = require(path.join(process.cwd(), 'package.json'));
+    const parcelVersion = packageJson && (packageJson.dependencies?.parcel || packageJson.devDependencies?.parcel);
+    if (parcelVersion) {
+        logger_1.default.success('Parcel detected in package.json. Macros are supported by default in v2.12.0 and newer.');
+        return { isMacroPluginInstalled: false, isMacroSupportEnabled: false };
+    }
+    let isMacroPluginInstalled = await (0, installPackage_1.default)('unplugin-parcel-macros', { dev: true });
+    // TODO: Try to automatically update bundle config
+    return { isMacroPluginInstalled, isMacroSupportEnabled: false };
+}

package/dist/s1-to-s2/src/utils/installPackage.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = installPackage;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const logger_js_1 = __importDefault(require("./logger.js"));
+const path_1 = __importDefault(require("path"));
+const execa = require('execa');
+function detectPackageManager() {
+    let packageManagers = [
+        { name: 'yarn', file: 'yarn.lock', installCommand: 'add' },
+        { name: 'npm', file: 'package-lock.json', installCommand: 'install' },
+        { name: 'pnpm', file: 'pnpm-lock.yaml', installCommand: 'add' }
+    ];
+    for (let pm of packageManagers) {
+        if (fs_1.default.existsSync(pm.file)) {
+            return pm;
+        }
+    }
+    return null;
+}
+function hasPackageJson() {
+    return fs_1.default.existsSync(path_1.default.join(process.cwd(), 'package.json'));
+}
+async function installPackage(packageName, options) {
+    logger_js_1.default.info('Checking for package.json...');
+    if (!hasPackageJson()) {
+        logger_js_1.default.warn(`Could not find package.json in the current directory. Please install ${chalk_1.default.bold(packageName)} manually.\n`);
+        return false;
+    }
+    let packageManager = detectPackageManager();
+    if (!packageManager) {
+        logger_js_1.default.warn(`Could not detect package manager. Please install ${chalk_1.default.bold(packageName)} manually.\n`);
+        return false;
+    }
+    try {
+        logger_js_1.default.info(`Installing ${chalk_1.default.bold(packageName)} using ${chalk_1.default.bold(packageManager.name)}...`);
+        await execa(packageManager.name, [packageManager.installCommand, `${packageName}@latest`, options?.dev ? '-D' : undefined]);
+        logger_js_1.default.success(`Successfully installed ${chalk_1.default.bold(packageName)}!\n`);
+        return true;
+    }
+    catch (e) {
+        logger_js_1.default.warn(`Failed to install ${chalk_1.default.bold(packageName)} with ${chalk_1.default.bold(packageManager.name)}.\n\nReceived error: ${e.message}.\n\nPlease install ${chalk_1.default.bold(packageName)} manually.\n`);
+        return false;
+    }
+}

package/dist/s1-to-s2/src/utils/logger.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+function info(message) {
+    console.log(chalk_1.default.cyan(message));
+}
+function success(message) {
+    console.log(chalk_1.default.green(`✓ ${message}`));
+}
+function warn(message) {
+    console.log(chalk_1.default.yellow(`WARNING: ${message}`));
+}
+function error(message) {
+    console.error(chalk_1.default.red(`ERROR: ${message}`));
+}
+exports.default = {
+    info,
+    success,
+    warn,
+    error
+};

package/dist/s1-to-s2/src/utils/waitForKeypress.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitForKeypress = waitForKeypress;
+async function waitForKeypress() {
+    await new Promise((resolve) => {
+        process.stdin.once('data', () => {
+            resolve();
+        });
+    });
+}

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const fs = require('fs');
+const path = require('path');
+function areSpecifiersAlphabetized(specifiers) {
+    const specifierNames = specifiers.map((specifier) => specifier.imported.name);
+    const sortedNames = [...specifierNames].sort();
+    return specifierNames.join() === sortedNames.join();
+}
+/**
+ * Replaces individual package imports with monopackage imports, where possible.
+ *
+ * Works for:
+ * - `@react-spectrum/*` -> `@adobe/react-spectrum`.
+ * - `@react-aria/*` -> `react-aria`.
+ * - `@react-stately/*` -> `react-stately`.
+ *
+ * By default this will apply to all the above packages, or optionally you can specify which packages to apply this by passing a comma-separated list to the packages option: `--packages=react-aria,react-stately,react-spectrum`.
+ *
+ * Run this from a directory where the relevant packages are installed in node_modules so it knows which monopackage exports are available to use (since exports may vary by version).
+ */
+function transformer(file, api, options) {
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    const packages = {
+        'react-spectrum': {
+            monopackage: '@adobe/react-spectrum',
+            individualPrefix: '@react-spectrum/'
+        },
+        'react-aria': {
+            monopackage: 'react-aria',
+            individualPrefix: '@react-aria/'
+        },
+        'react-stately': {
+            monopackage: 'react-stately',
+            individualPrefix: '@react-stately/'
+        }
+    };
+    const selectedPackages = options?.packages?.split(',').filter((pkg) => packages[pkg]) ||
+        Object.keys(packages);
+    let anyIndexFound = false;
+    const monopackageExports = {};
+    selectedPackages.forEach((pkg) => {
+        const indexPath = path.join(process.cwd(), `node_modules/${packages[pkg].monopackage}/dist/types.d.ts`);
+        if (fs.existsSync(indexPath)) {
+            anyIndexFound = true;
+            const indexFile = fs.readFileSync(indexPath, 'utf8');
+            const indexRoot = j(indexFile);
+            monopackageExports[pkg] = [];
+            // Collect all named exports from the monopackage index file
+            indexRoot.find(j.ExportNamedDeclaration).forEach((path) => {
+                path.node.specifiers?.forEach((specifier) => {
+                    monopackageExports[pkg].push(specifier.exported.name);
+                });
+            });
+            // Collect all exports defined in export statements like "export { Component } from '...' "
+            indexRoot
+                .find(j.ExportNamedDeclaration, {
+                source: {
+                    type: 'Literal'
+                }
+            })
+                .forEach((path) => {
+                path.node.specifiers?.forEach((specifier) => {
+                    monopackageExports[pkg].push(specifier.exported.name);
+                });
+            });
+        }
+        else if (options?.packages?.split(',').includes(pkg)) {
+            console.warn(`The index file for ${packages[pkg].monopackage} at ${indexPath} does not exist. Ensure that ${packages[pkg].monopackage} is installed.`);
+        }
+    });
+    if (!anyIndexFound) {
+        console.warn('None of the index files for the selected packages exist. Ensure that the packages are installed.');
+        return root.toSource();
+    }
+    selectedPackages.forEach((pkg) => {
+        // Find all imports from individual packages
+        const individualPackageImports = root
+            .find(j.ImportDeclaration)
+            .filter((path) => {
+            return path.node.source.value?.startsWith(packages[pkg].individualPrefix);
+        });
+        if (individualPackageImports.size() === 0) {
+            return;
+        }
+        // Collect all imported specifiers from individual packages that are also in the monopackage exports
+        const importedSpecifiers = individualPackageImports
+            .nodes()
+            .reduce((acc, node) => {
+            node.specifiers?.forEach((specifier) => {
+                if (monopackageExports[pkg].includes(specifier.imported.name)) {
+                    acc.push(specifier);
+                }
+            });
+            return acc;
+        }, []);
+        // Remove the old imports if they are present in monopackage exports
+        individualPackageImports.forEach((path) => {
+            path.node.specifiers = path.node.specifiers?.filter((specifier) => !monopackageExports[pkg].includes(specifier.imported.name));
+        });
+        // Remove import declarations with no specifiers left
+        individualPackageImports
+            .filter((path) => path.node.specifiers?.length === 0)
+            .remove();
+        // Find existing monopackage import if it exists
+        const monopackageImport = root.find(j.ImportDeclaration).filter((path) => {
+            return path.node.source.value === packages[pkg].monopackage;
+        });
+        if (monopackageImport.size() > 0) {
+            const existingImport = monopackageImport.at(0).get().node;
+            const specifiers = existingImport.specifiers;
+            if (areSpecifiersAlphabetized(specifiers)) {
+                // If imports are sorted, add the new import in sorted order
+                importedSpecifiers.forEach((newSpecifier) => {
+                    const index = specifiers.findIndex((specifier) => specifier.imported.name > newSpecifier.imported.name);
+                    if (index === -1) {
+                        specifiers.push(newSpecifier);
+                    }
+                    else {
+                        specifiers.splice(index, 0, newSpecifier);
+                    }
+                });
+            }
+            else {
+                // If imports are not sorted, add the new import to the end
+                specifiers.push(...importedSpecifiers);
+            }
+        }
+        else if (importedSpecifiers.length > 0) {
+            // Create a new monopackage import with the collected specifiers
+            const newImport = j.importDeclaration(importedSpecifiers, j.literal(packages[pkg].monopackage));
+            // Insert the new import below the last existing import
+            const lastImport = root.find(j.ImportDeclaration).at(-1);
+            if (lastImport.size() > 0) {
+                lastImport.insertAfter(newImport);
+            }
+            else {
+                root.get().node.program.body.unshift(newImport);
+            }
+        }
+    });
+    return root.toSource();
+}
+transformer.parser = 'tsx';

package/dist/use-monopackages/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_monopackages = use_monopackages;
+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_monopackages(options) {
+    let { path: filePath = '.', ...rest } = options;
+    return await (0, Runner_js_1.run)(transformPath, [filePath], rest);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@react-spectrum/codemods",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "source": "src/index.ts",
+  "bin": "dist/index.js",
+  "targets": {
+    "main": false
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "yarn build"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "commonjs",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adobe/react-spectrum"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.24.5",
+    "@babel/traverse": "^7.24.5",
+    "@babel/types": "^7.24.5",
+    "@react-spectrum/s2": "^0.3.0",
+    "@react-types/shared": "^3.24.0",
+    "@types/node": "^20",
+    "boxen": "^5.1.2",
+    "build": "^0.1.4",
+    "chalk": "^4.0.0",
+    "execa": "^5.1.1",
+    "jscodeshift": "^0.15.2",
+    "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0",
+    "ts-node": "^10.9.2",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/jscodeshift": "^0.11.11",
+    "react-dom": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0",
+    "typescript": "^5.5.0"
+  },
+  "rsp": {
+    "type": "cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "faf0e18467231422cb7a06eb92a74d04e271f1e8"
+}