@vkontakte/vkui-codemods 0.0.3

package/README.md

@@ -0,0 +1,63 @@
+# VKUI v6 Codemods
+
+Чтобы упростить переход на новую мажорную версию, можно воспользоваться инструментом по автоматической миграции ваших компонентов.
+
+> Для начала обновите ваше приложение до новой мажорной версии (**v6**) в соответствии с требованиями вашего пакетного менеджера и среды
+
+> Обратите внимание, минимальная поддерживаемая версия **React** увеличена до `v18.2.0`
+
+> Пока для перевода доступны только `Typescript`-файлы (_.ts/_.tsx)
+
+Перейдите в директорию с исходниками вашего проекта (обычно это `src/`) и запустите следующую команду:
+
+```shell
+npx @vkontakte/vkui-codemods
+```
+
+Инструмент представляет собой консольное приложение, с помощью которого вы можете выбрать необходимые изменения и применить их, доступны следующие команды:
+
+```
+$ npx @vkontakte/vkui-codemods --help
+
+Usage: @vkontakte/vkui-codemod [codemod-name]
+
+Arguments:
+ codemod-name              which codemod should be applied
+
+Options:
+ -V, --version             output the version number
+ -l --list                 list available codemods
+ --all                     apply all available codemods
+ -p --path <paths>         path to files in which to apply the codemods (default: current directory)
+ --dry-run                 no changes are made to files
+ --ignore-config <config>  ignore files if they match patterns sourced from a configuration file (e.g. a .gitignore)
+ --debug                   all logs are shown
+ --alias <alias>           in case you have adapter over original library (default: "@vkontakte/vkui")
+ -h, --help                display help for command
+```
+
+При запуске приложения без аргументов будет предложено выбрать один из имеющихся codemod (их название отражает название компонента, к которому будет применено изменение). Если вам необходимо применить все имеющиеся codemods, запустите команду с опцией `--all`:
+
+```shell
+npx @vkontakte/vkui-codemods --all
+```
+
+Если вы хотите исключить некоторые файлы или директории из обработки, то временно создайте файл (по примеру .gitignore) с перечисленными исключениями:
+
+```shell
+npx @vkontakte/vkui-codemods --all --path "./examples" --ignore-config "./.codemodignore"
+```
+
+```
+// .codemodignore
+MyBeautifulComponentToIgnore.tsx
+directoryToIgnore/
+```
+
+Приведенная выше команда применит все codemods в директории `examples` (находится в корне текущей директории), игонорируя файл `MyBeautifulComponentToIgnore.tsx` и директорию `directoryToIgnore`, указанные в `.codemodignore` (находится в корне текущей директории)
+
+> Обратите внимание, если вы используете собственный адаптер над библиотекой `VKUI` и делаете ре-экспорт существующих компонентов, то можете воспользоваться опцией `--alias` для указания правильного пути.
+
+```shell
+npx @vkontakte/vkui-codemods --all --alias "@myscope/VKUIFake"
+```

package/dist/cli.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+var commander_1 = require("commander");
+var prompts_1 = __importDefault(require("prompts"));
+var getAvailableCodemods_js_1 = __importDefault(require("./getAvailableCodemods.js"));
+var logger_js_1 = __importDefault(require("./helpers/logger.js"));
+var package_json_1 = __importDefault(require("../package.json"));
+var trimStringValue = function (value) {
+    return typeof value === 'string' ? value.trim() : value;
+};
+var promptAvailableCodemods = function (codemods) { return __awaiter(void 0, void 0, void 0, function () {
+    var codemod;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, prompts_1.default)({
+                    type: 'select',
+                    name: 'codemod',
+                    message: 'Pick a codemod',
+                    initial: 0,
+                    choices: codemods.map(function (name) { return ({ title: name, value: name }); }),
+                }, {
+                    onCancel: function () {
+                        process.exit(1);
+                    },
+                })];
+            case 1:
+                codemod = (_a.sent()).codemod;
+                return [2 /*return*/, codemod];
+        }
+    });
+}); };
+var runCli = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var program, options, codemodName, codemods, codemods;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                program = new commander_1.Command('@vkontakte/vkui-codemod')
+                    .version(package_json_1.default.version || 'unknown')
+                    .argument('[codemod-name]', 'which codemod should be applied', trimStringValue)
+                    .usage("".concat(chalk_1.default.green('[codemod-name]')))
+                    .option('-l --list', 'list available codemods')
+                    .option('--all', 'apply all available codemods')
+                    .option('-p --path <paths>', 'path to files in which to apply the codemods')
+                    .option('--dry-run', 'no changes are made to files')
+                    .option('--ignore-config <config>', 'ignore files if they match patterns sourced from a configuration file (e.g. a .gitignore)')
+                    .option('--debug', "all logs are shown")
+                    .option('--alias <alias>', "in case you have adapter over original library", '@vkontakte/vkui')
+                    .configureOutput({
+                    writeErr: function (str) { return logger_js_1.default.info("".concat(chalk_1.default.red(str))); },
+                })
+                    .parse(process.argv);
+                options = program.opts();
+                codemodName = program.args[0];
+                if (options.list) {
+                    codemods = (0, getAvailableCodemods_js_1.default)();
+                    logger_js_1.default.info(codemods);
+                    process.exit(0);
+                }
+                if (!(!codemodName && !options.all)) return [3 /*break*/, 2];
+                codemods = (0, getAvailableCodemods_js_1.default)();
+                return [4 /*yield*/, promptAvailableCodemods(codemods)];
+            case 1:
+                codemodName = _a.sent();
+                _a.label = 2;
+            case 2: return [2 /*return*/, {
+                    flags: options,
+                    codemodName: codemodName,
+                }];
+        }
+    });
+}); };
+exports.runCli = runCli;

package/dist/codemod-helpers.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAttributeManipulator = exports.renameProp = exports.getImportInfo = void 0;
+function getImportInfo(j, file, componentName, alias) {
+    var source = j(file.source);
+    var localImportName = componentName;
+    var componentImport = source
+        .find(j.ImportDeclaration)
+        .filter(function (path) { return path.node.source.value === alias; })
+        .find(j.ImportSpecifier, { imported: { name: componentName } });
+    componentImport.forEach(function (path) {
+        if (path.node.local && path.node.local.name !== path.node.imported.name) {
+            localImportName = path.node.local.name;
+        }
+    });
+    return { localName: localImportName };
+}
+exports.getImportInfo = getImportInfo;
+function renameProp(j, source, componentName, renameMap) {
+    var from = Object.keys(renameMap);
+    return source
+        .find(j.JSXOpeningElement)
+        .filter(function (path) { return path.value.name.type === 'JSXIdentifier' && path.value.name.name === componentName; })
+        .find(j.JSXAttribute)
+        .filter(function (attribute) {
+        var attributeName = attribute.node.name.name;
+        return typeof attributeName === 'string' ? from.includes(attributeName) : false;
+    })
+        .forEach(function (attribute) {
+        j(attribute).replaceWith(j.jsxAttribute(j.jsxIdentifier(renameMap[attribute.node.name.name]), attribute.node.value));
+    });
+}
+exports.renameProp = renameProp;
+var createAttributeManipulator = function (props, api) {
+    var map = new Map(Object.entries(props));
+    return {
+        has: function (attributeKey) {
+            return typeof attributeKey === 'string' ? map.has(attributeKey) : false;
+        },
+        getReplacers: function (attributeKeyProp) {
+            var attributeKey = typeof attributeKeyProp === 'string' ? attributeKeyProp : '';
+            var found = map.get(attributeKey);
+            if (found && found.reportText) {
+                var text = typeof found.reportText === 'function' ? found.reportText() : found.reportText;
+                try {
+                    api.report(text);
+                }
+                catch (_a) {
+                    console.warn(text);
+                }
+            }
+            return {
+                action: found && found.action,
+                keyTo: function () {
+                    if (!found || !found.keyTo) {
+                        return attributeKey;
+                    }
+                    if (typeof found.keyTo === 'string') {
+                        return found.keyTo;
+                    }
+                    return found.keyTo(attributeKey);
+                },
+                valueTo: function (attributeKeyValue) {
+                    if (!found || !found.valueTo) {
+                        return attributeKeyValue;
+                    }
+                    if (typeof found.valueTo === 'string') {
+                        return found.valueTo;
+                    }
+                    return found.valueTo(attributeKeyValue, api);
+                },
+            };
+        },
+    };
+};
+exports.createAttributeManipulator = createAttributeManipulator;

package/dist/getAvailableCodemods.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRANSFORM_DIR = void 0;
+var fs_1 = __importDefault(require("fs"));
+exports.TRANSFORM_DIR = "".concat(__dirname, "/transforms");
+var CODEMODS = [];
+function getAvailableCodemods() {
+    if (CODEMODS.length === 0) {
+        CODEMODS = fs_1.default
+            .readdirSync(exports.TRANSFORM_DIR)
+            .filter(function (fname) { return fname.endsWith('.js'); })
+            .map(function (fname) { return fname.slice(0, -3); });
+    }
+    return CODEMODS;
+}
+exports.default = getAvailableCodemods;

package/dist/helpers/logger.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var Logger = /** @class */ (function () {
+    function Logger() {
+        this.quiet = false;
+    }
+    Logger.prototype.setQuietMode = function () {
+        this.quiet = true;
+    };
+    Logger.prototype.log = function (level, message) {
+        if (this.quiet) {
+            return;
+        }
+        console.log("[".concat(level, "]: "), message, '\n');
+    };
+    Logger.prototype.debug = function (message) {
+        this.log('debug', message);
+    };
+    Logger.prototype.info = function (message) {
+        this.log('info', message);
+    };
+    Logger.prototype.warn = function (message) {
+        this.log('warn', message);
+    };
+    Logger.prototype.error = function (message) {
+        this.log('error', message);
+    };
+    return Logger;
+}());
+exports.default = new Logger();

package/dist/index.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var chalk_1 = __importDefault(require("chalk"));
+var cross_spawn_1 = require("cross-spawn");
+var prompts_1 = __importDefault(require("prompts"));
+var cli_js_1 = require("./cli.js");
+var getAvailableCodemods_js_1 = __importStar(require("./getAvailableCodemods.js"));
+var logger_js_1 = __importDefault(require("./helpers/logger.js"));
+function runJSCodeShift(codemodName, workingDirectory, flags) {
+    var args = ['--parser=tsx', '--extensions=tsx,ts', "--alias=".concat(flags.alias)];
+    if (flags.dryRun) {
+        args.push('--dry');
+    }
+    if (flags.ignoreConfig) {
+        args.push("--ignore-config=".concat(flags.ignoreConfig));
+    }
+    if (!flags.debug) {
+        args.push('--silent');
+    }
+    var result = (0, cross_spawn_1.sync)('node', __spreadArray(__spreadArray([
+        require.resolve('jscodeshift/bin/jscodeshift'),
+        '--no-babel',
+        '--fail-on-error',
+        '-t',
+        "".concat(getAvailableCodemods_js_1.TRANSFORM_DIR, "/").concat(codemodName, ".js")
+    ], args, true), [
+        workingDirectory,
+    ], false), {
+        stdio: 'inherit',
+        shell: true,
+    });
+    if (result.status === 1) {
+        logger_js_1.default.error("Codemod ".concat(codemodName, " failed to apply"));
+        return;
+    }
+}
+function promptConfirmation() {
+    return __awaiter(this, void 0, void 0, function () {
+        var confirmation;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, prompts_1.default)({
+                        type: 'toggle',
+                        name: 'confirmation',
+                        message: "Would you like to continue?",
+                        initial: true,
+                        active: 'Yes',
+                        inactive: 'No',
+                    }, {
+                        onCancel: function () {
+                            process.exit(1);
+                        },
+                    })];
+                case 1:
+                    confirmation = (_a.sent()).confirmation;
+                    return [2 /*return*/, confirmation];
+            }
+        });
+    });
+}
+function verifyConfiguration(workingDirectory, codemodName) {
+    return __awaiter(this, void 0, void 0, function () {
+        var confirmed;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    logger_js_1.default.info("Please ".concat(chalk_1.default.cyan('verify'), " the following information:\n        working directory: ").concat(workingDirectory, "\n        codemod to apply: ").concat(codemodName ? codemodName : chalk_1.default.red('all'), "\n      "));
+                    return [4 /*yield*/, promptConfirmation()];
+                case 1:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        logger_js_1.default.info('Exiting without changes...');
+                        process.exit(0);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+var run = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, flags, codemodName, workingDirectory, codemodes, codemodes;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, (0, cli_js_1.runCli)()];
+            case 1:
+                _a = _b.sent(), flags = _a.flags, codemodName = _a.codemodName;
+                workingDirectory = flags.path ? flags.path : process.cwd();
+                if (!(codemodName && workingDirectory)) return [3 /*break*/, 4];
+                codemodes = (0, getAvailableCodemods_js_1.default)();
+                if (!codemodes.includes(codemodName)) return [3 /*break*/, 3];
+                return [4 /*yield*/, verifyConfiguration(workingDirectory, codemodName)];
+            case 2:
+                _b.sent();
+                logger_js_1.default.info("\n 🚀 Let's go!");
+                runJSCodeShift(codemodName, workingDirectory, flags);
+                return [3 /*break*/, 4];
+            case 3:
+                logger_js_1.default.error("Codemod ".concat(codemodName, " doesn't exist. Please check the available codemods by running with --list option"));
+                process.exit(0);
+                _b.label = 4;
+            case 4:
+                if (!(flags.all && workingDirectory)) return [3 /*break*/, 6];
+                return [4 /*yield*/, verifyConfiguration(workingDirectory)];
+            case 5:
+                _b.sent();
+                logger_js_1.default.info("\n 🚀 Let's go!");
+                codemodes = (0, getAvailableCodemods_js_1.default)();
+                codemodes.forEach(function (codemod) {
+                    logger_js_1.default.info("Codemod ".concat(codemod, " in process..."));
+                    runJSCodeShift(codemod, workingDirectory, flags);
+                });
+                _b.label = 6;
+            case 6:
+                logger_js_1.default.info("\n    All done! Please check if everything is applied correctly. \n    If it's not the case - feel free to contact VKUI Team. \n    Happy coding with ".concat(chalk_1.default.green.bold('v6'), "!"));
+                return [2 /*return*/];
+        }
+    });
+}); };
+run().catch(function (error) {
+    logger_js_1.default.error(error);
+});

package/dist/report.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.report = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+var package_json_1 = __importDefault(require("../package.json"));
+function report(api, message) {
+    var report = api.report;
+    report("".concat(message, " Advise ").concat(chalk_1.default.white.bgBlue.bold('migration guide'), " - ").concat(package_json_1.default.homepage, "#/Migration \n\n"));
+}
+exports.report = report;

package/dist/transforms/accordion.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parser = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+var codemod_helpers_1 = require("../codemod-helpers");
+var report_1 = require("../report");
+exports.parser = 'tsx';
+function transformer(file, api, options) {
+    var alias = options.alias;
+    var j = api.jscodeshift;
+    var source = j(file.source);
+    var localName = (0, codemod_helpers_1.getImportInfo)(j, file, 'Accordion', alias).localName;
+    (0, codemod_helpers_1.renameProp)(j, source, localName, { open: 'expanded' });
+    var accordionComponents = source
+        .find(j.JSXOpeningElement)
+        .filter(function (path) { return path.value.name.type === 'JSXIdentifier' && path.value.name.name === localName; });
+    if (accordionComponents.length > 0) {
+        (0, report_1.report)(api, ": ".concat(chalk_1.default.white.bgBlue('Accordion'), " has been changed. Manual changes required."));
+    }
+    return source.toSource();
+}
+exports.default = transformer;

package/dist/transforms/action-sheet-item.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parser = void 0;
+var codemod_helpers_1 = require("../codemod-helpers");
+exports.parser = 'tsx';
+function transformer(file, api, options) {
+    var alias = options.alias;
+    var j = api.jscodeshift;
+    var source = j(file.source);
+    var localName = (0, codemod_helpers_1.getImportInfo)(j, file, 'ActionSheetItem', alias).localName;
+    source
+        .find(j.JSXOpeningElement)
+        .filter(function (path) { return path.value.name.type === 'JSXIdentifier' && path.value.name.name === localName; })
+        .find(j.JSXAttribute)
+        .filter(function (attribute) { return attribute.node.name.name === 'autoClose'; })
+        .forEach(function (attribute) {
+        var node = attribute.node;
+        if (!node.value) {
+            j(attribute).remove();
+        }
+        else if (node.value.type === 'JSXExpressionContainer' &&
+            node.value.expression.type === 'BooleanLiteral') {
+            if (node.value.expression.value) {
+                j(attribute).remove();
+            }
+            else {
+                j(attribute).replaceWith(j.jsxAttribute(j.jsxIdentifier('autoCloseDisabled')));
+            }
+        }
+    });
+    return source.toSource();
+}
+exports.default = transformer;

package/dist/transforms/action-sheet.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parser = void 0;
+var chalk_1 = __importDefault(require("chalk"));
+var codemod_helpers_1 = require("../codemod-helpers");
+var report_1 = require("../report");
+exports.parser = 'tsx';
+function transformer(file, api, options) {
+    var alias = options.alias;
+    var j = api.jscodeshift;
+    var source = j(file.source);
+    var localName = (0, codemod_helpers_1.getImportInfo)(j, file, 'ActionSheet', alias).localName;
+    var openingTargetElements = source
+        .find(j.JSXOpeningElement)
+        .filter(function (path) { return path.value.name.type === 'JSXIdentifier' && path.value.name.name === localName; });
+    openingTargetElements.forEach(function (path) {
+        var attributes = path.value.attributes;
+        var noRequiredProp = true;
+        if (attributes) {
+            attributes.forEach(function (attr) {
+                if (attr.type === 'JSXAttribute') {
+                    if (attr.name.name === 'toggleRef') {
+                        noRequiredProp = false;
+                    }
+                    if (attr.name.name === 'popupDirection' && attr.value) {
+                        if (attr.value.type === 'StringLiteral') {
+                            attr.name.name = 'placement';
+                        }
+                        else {
+                            (0, report_1.report)(api, ": prop ".concat(chalk_1.default.white.bgBlue('popupDirection'), " in ").concat(chalk_1.default.white.bgBlue('ActionSheet'), " must be replaced manually."));
+                        }
+                    }
+                }
+            });
+        }
+        if (noRequiredProp) {
+            (0, report_1.report)(api, ": prop ".concat(chalk_1.default.white.bgBlue('toggleRef'), " in ").concat(chalk_1.default.white.bgBlue('ActionSheet'), " is required."));
+        }
+    });
+    return source.toSource();
+}
+exports.default = transformer;

package/dist/transforms/alert.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parser = void 0;
+var codemod_helpers_1 = require("../codemod-helpers");
+exports.parser = 'tsx';
+function replaceInArrayExpression(j, path) {
+    j(path)
+        .find(j.ArrayExpression)
+        .find(j.ObjectExpression)
+        .find(j.ObjectProperty)
+        .filter(function (path) { return path.value.key.type === 'Identifier' && path.value.key.name === 'autoClose'; })
+        .forEach(function (property) {
+        var propertyValue = property.value;
+        if (propertyValue.value.type === 'BooleanLiteral') {
+            if (propertyValue.value.value) {
+                j(property).remove();
+            }
+            else {
+                j(property).replaceWith(j.property('init', j.jsxIdentifier('autoCloseDisabled'), j.booleanLiteral(true)));
+            }
+        }
+    });
+}
+function transformer(file, api, options) {
+    var alias = options.alias;
+    var j = api.jscodeshift;
+    var source = j(file.source);
+    var localName = (0, codemod_helpers_1.getImportInfo)(j, file, 'Alert', alias).localName;
+    source
+        .find(j.JSXOpeningElement)
+        .filter(function (path) { return path.value.name.type === 'JSXIdentifier' && path.value.name.name === localName; })
+        .find(j.JSXAttribute)
+        .filter(function (attribute) { return attribute.node.name.name === 'actions'; })
+        .forEach(function (attribute) {
+        var node = attribute.node.value;
+        if (node && node.type === 'JSXExpressionContainer') {
+            replaceInArrayExpression(j, attribute);
+            if (node.expression.type === 'Identifier') {
+                var decl = source.findVariableDeclarators(node.expression.name);
+                decl.forEach(function (path) {
+                    replaceInArrayExpression(j, path);
+                });
+            }
+        }
+    });
+    return source.toSource();
+}
+exports.default = transformer;