@atlaskit/codemod-cli 0.34.8 → 1.0.0

package/dist/esm/presets/remove-token-fallbacks/after-all.js

@@ -0,0 +1,331 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/* eslint-disable no-console */
+import { exec } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { findRoot } from '@manypkg/find-root';
+import chalk from 'chalk';
+import { chunkArray } from './utils/chunk';
+import { combineReports } from './utils/combine-reports';
+var execAsync = promisify(exec);
+function gitStage(_x, _x2) {
+  return _gitStage.apply(this, arguments);
+}
+function _gitStage() {
+  _gitStage = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(filePaths, cwd) {
+    var gitAddCommand, _yield$execAsync, gitAddStdout, gitAddStderr;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          gitAddCommand = "git add ".concat(filePaths.join(' '));
+          console.log("Executing command: ".concat(gitAddCommand));
+          _context.next = 4;
+          return execAsync(gitAddCommand, {
+            cwd: cwd
+          });
+        case 4:
+          _yield$execAsync = _context.sent;
+          gitAddStdout = _yield$execAsync.stdout;
+          gitAddStderr = _yield$execAsync.stderr;
+          if (gitAddStdout) {
+            console.log(chalk.blue("Git add output:\n".concat(gitAddStdout)));
+          }
+          if (gitAddStderr) {
+            console.error(chalk.yellow("Git add errors:\n".concat(gitAddStderr)));
+          }
+          console.log(chalk.green("All changes have been staged."));
+        case 10:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _gitStage.apply(this, arguments);
+}
+function runPrettier(_x3, _x4) {
+  return _runPrettier.apply(this, arguments);
+}
+function _runPrettier() {
+  _runPrettier = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(filePaths, cwd) {
+    var prettierCommand, _yield$execAsync2, prettierStdout, prettierStderr;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          prettierCommand = "yarn prettier --write ".concat(filePaths.join(' '));
+          console.log("Executing command: ".concat(prettierCommand));
+          _context2.next = 4;
+          return execAsync(prettierCommand, {
+            cwd: cwd
+          });
+        case 4:
+          _yield$execAsync2 = _context2.sent;
+          prettierStdout = _yield$execAsync2.stdout;
+          prettierStderr = _yield$execAsync2.stderr;
+          if (prettierStdout) {
+            console.log(chalk.blue("Prettier output:\n".concat(prettierStdout)));
+          }
+          if (prettierStderr) {
+            console.error(chalk.yellow("Prettier errors:\n".concat(prettierStderr)));
+          }
+          console.log(chalk.green("Prettier was run successfully"));
+        case 10:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _runPrettier.apply(this, arguments);
+}
+function runEslint(_x5, _x6) {
+  return _runEslint.apply(this, arguments);
+}
+function _runEslint() {
+  _runEslint = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(filePaths, cwd) {
+    var fileChunks, totalChunks, _iterator, _step, _loop;
+    return _regeneratorRuntime.wrap(function _callee4$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          fileChunks = chunkArray(filePaths, 20);
+          totalChunks = fileChunks.length;
+          _iterator = _createForOfIteratorHelper(fileChunks.entries());
+          _context6.prev = 3;
+          _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
+            var _step$value, chunkIndex, fileChunk, eslintCommand, result, stdout, stderr, smallerChunks, totalSmallerChunks, _iterator2, _step2, _loop2;
+            return _regeneratorRuntime.wrap(function _loop$(_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _step$value = _slicedToArray(_step.value, 2), chunkIndex = _step$value[0], fileChunk = _step$value[1];
+                  eslintCommand = "yarn eslint ".concat(fileChunk.join(' '), " --report-unused-disable-directives --fix");
+                  console.log("Executing command for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ": ").concat(eslintCommand));
+                  _context5.prev = 3;
+                  _context5.next = 6;
+                  return execAsync(eslintCommand, {
+                    cwd: cwd
+                  });
+                case 6:
+                  result = _context5.sent;
+                  stdout = result.stdout, stderr = result.stderr;
+                  if (stdout) {
+                    console.log(chalk.blue("ESLint output for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ":\n").concat(stdout)));
+                  }
+                  if (stderr) {
+                    console.error(chalk.yellow("ESLint errors for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ":\n").concat(stderr)));
+                  }
+                  _context5.next = 34;
+                  break;
+                case 12:
+                  _context5.prev = 12;
+                  _context5.t0 = _context5["catch"](3);
+                  console.error(chalk.red("Error running ESLint on chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ": ").concat(_context5.t0)));
+
+                  // Retry each file individually
+                  console.log(chalk.yellow("Retrying each file in chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, " individually...")));
+
+                  // Chunk the files into smaller groups of 5 for parallel retry
+                  smallerChunks = chunkArray(fileChunk, 5);
+                  totalSmallerChunks = smallerChunks.length;
+                  _iterator2 = _createForOfIteratorHelper(smallerChunks.entries());
+                  _context5.prev = 19;
+                  _loop2 = /*#__PURE__*/_regeneratorRuntime.mark(function _loop2() {
+                    var _step2$value, smallChunkIndex, smallerChunk;
+                    return _regeneratorRuntime.wrap(function _loop2$(_context4) {
+                      while (1) switch (_context4.prev = _context4.next) {
+                        case 0:
+                          _step2$value = _slicedToArray(_step2.value, 2), smallChunkIndex = _step2$value[0], smallerChunk = _step2$value[1];
+                          _context4.next = 3;
+                          return Promise.all(smallerChunk.map( /*#__PURE__*/function () {
+                            var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(file) {
+                              var individualEslintCommand, _result, _stdout, _stderr;
+                              return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+                                while (1) switch (_context3.prev = _context3.next) {
+                                  case 0:
+                                    _context3.prev = 0;
+                                    individualEslintCommand = "yarn eslint ".concat(file, " --report-unused-disable-directives --fix");
+                                    console.log("Executing command for file in small chunk ".concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ": ").concat(individualEslintCommand));
+                                    _context3.next = 5;
+                                    return execAsync(individualEslintCommand, {
+                                      cwd: cwd
+                                    });
+                                  case 5:
+                                    _result = _context3.sent;
+                                    _stdout = _result.stdout, _stderr = _result.stderr;
+                                    if (_stdout) {
+                                      console.log(chalk.blue("ESLint output for file ".concat(file, " in small chunk ").concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ":\n").concat(_stdout)));
+                                    }
+                                    if (_stderr) {
+                                      console.error(chalk.yellow("ESLint errors for file ".concat(file, " in small chunk ").concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ":\n").concat(_stderr)));
+                                    }
+                                    _context3.next = 14;
+                                    break;
+                                  case 11:
+                                    _context3.prev = 11;
+                                    _context3.t0 = _context3["catch"](0);
+                                    console.error(chalk.red("Error running ESLint on file ".concat(file, " in small chunk ").concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ": ").concat(_context3.t0)));
+                                  case 14:
+                                  case "end":
+                                    return _context3.stop();
+                                }
+                              }, _callee3, null, [[0, 11]]);
+                            }));
+                            return function (_x8) {
+                              return _ref.apply(this, arguments);
+                            };
+                          }()));
+                        case 3:
+                        case "end":
+                          return _context4.stop();
+                      }
+                    }, _loop2);
+                  });
+                  _iterator2.s();
+                case 22:
+                  if ((_step2 = _iterator2.n()).done) {
+                    _context5.next = 26;
+                    break;
+                  }
+                  return _context5.delegateYield(_loop2(), "t1", 24);
+                case 24:
+                  _context5.next = 22;
+                  break;
+                case 26:
+                  _context5.next = 31;
+                  break;
+                case 28:
+                  _context5.prev = 28;
+                  _context5.t2 = _context5["catch"](19);
+                  _iterator2.e(_context5.t2);
+                case 31:
+                  _context5.prev = 31;
+                  _iterator2.f();
+                  return _context5.finish(31);
+                case 34:
+                  console.log(chalk.green("Finished running ESLint for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ".")));
+                case 35:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _loop, null, [[3, 12], [19, 28, 31, 34]]);
+          });
+          _iterator.s();
+        case 6:
+          if ((_step = _iterator.n()).done) {
+            _context6.next = 10;
+            break;
+          }
+          return _context6.delegateYield(_loop(), "t0", 8);
+        case 8:
+          _context6.next = 6;
+          break;
+        case 10:
+          _context6.next = 15;
+          break;
+        case 12:
+          _context6.prev = 12;
+          _context6.t1 = _context6["catch"](3);
+          _iterator.e(_context6.t1);
+        case 15:
+          _context6.prev = 15;
+          _iterator.f();
+          return _context6.finish(15);
+        case 18:
+          console.log(chalk.green("ESLint was run on all files successfully"));
+        case 19:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee4, null, [[3, 12, 15, 18]]);
+  }));
+  return _runEslint.apply(this, arguments);
+}
+export function afterAll(_x7) {
+  return _afterAll.apply(this, arguments);
+}
+function _afterAll() {
+  _afterAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(options) {
+    var filesTxtPath, fileContent, filePaths, firstFilePath, rootDir;
+    return _regeneratorRuntime.wrap(function _callee5$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          if (!options.reportFolder) {
+            _context7.next = 3;
+            break;
+          }
+          _context7.next = 3;
+          return combineReports(options.reportFolder);
+        case 3:
+          if (!(options.reportFolder && !options.dry)) {
+            _context7.next = 35;
+            break;
+          }
+          _context7.prev = 4;
+          filesTxtPath = path.join(options.reportFolder, 'files.txt');
+          _context7.next = 8;
+          return fs.readFile(filesTxtPath, 'utf-8');
+        case 8:
+          fileContent = _context7.sent;
+          if (!(fileContent.length > 0)) {
+            _context7.next = 30;
+            break;
+          }
+          filePaths = fileContent.split(/\r?\n/).filter(Boolean); // Get the first file path and strip any quotes
+          firstFilePath = filePaths[0].replace(/^['"]|['"]$/g, ''); // Determine the root directory using findRoot
+          _context7.next = 14;
+          return findRoot(path.dirname(firstFilePath));
+        case 14:
+          rootDir = _context7.sent;
+          console.log('Root directory:', rootDir);
+          _context7.next = 18;
+          return gitStage(filePaths, rootDir);
+        case 18:
+          if (options.skipEslint) {
+            _context7.next = 23;
+            break;
+          }
+          _context7.next = 21;
+          return runEslint(filePaths, rootDir);
+        case 21:
+          _context7.next = 24;
+          break;
+        case 23:
+          if (options.verbose) {
+            console.log(chalk.blue('Skipping ESLint post-processing as requested.'));
+          }
+        case 24:
+          if (options.skipPrettier) {
+            _context7.next = 29;
+            break;
+          }
+          _context7.next = 27;
+          return runPrettier(filePaths, rootDir);
+        case 27:
+          _context7.next = 30;
+          break;
+        case 29:
+          if (options.verbose) {
+            console.log(chalk.blue('Skipping Prettier post-processing as requested.'));
+          }
+        case 30:
+          _context7.next = 35;
+          break;
+        case 32:
+          _context7.prev = 32;
+          _context7.t0 = _context7["catch"](4);
+          if (_context7.t0 instanceof Error) {
+            console.error(chalk.red("Unexpected error: ".concat(_context7.t0.message)));
+          } else {
+            console.error(chalk.red('An unknown error occurred.'));
+          }
+        case 35:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee5, null, [[4, 32]]);
+  }));
+  return _afterAll.apply(this, arguments);
+}

package/dist/esm/presets/remove-token-fallbacks/before-all.js

@@ -0,0 +1,27 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/* eslint-disable no-console */
+
+import { clearFolder } from './utils/clear-folder';
+export function beforeAll(_x) {
+  return _beforeAll.apply(this, arguments);
+}
+function _beforeAll() {
+  _beforeAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(options) {
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (!options.reportFolder) {
+            _context.next = 3;
+            break;
+          }
+          _context.next = 3;
+          return clearFolder(options.reportFolder);
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _beforeAll.apply(this, arguments);
+}