@atlaskit/codemod-cli 0.27.4 → 0.28.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/codemod-cli
 
+## 0.28.1
+
+### Patch Changes
+
+- Updated dependencies
+
+## 0.28.0
+
+### Minor Changes
+
+- [#135751](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/135751)
+  [`320e4346043c0`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/320e4346043c0) -
+  Allows specifying multiple ignore patterns using | symbol. Fixes minor issues in
+  remove-token-fallbacks preset
+
 ## 0.27.4
 
 ### Patch Changes

package/dist/cjs/main.js

@@ -135,7 +135,7 @@ var resolveTransform = /*#__PURE__*/function () {
 }();
 var runTransform = /*#__PURE__*/function () {
   var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(filePaths, transform, flags) {
-    var logger, codemodDirs, transformPath, args, jscodeshiftContent, jscodeshiftContentNew, transformModule;
+    var logger, codemodDirs, transformPath, ignorePatterns, ignoreArgs, args, jscodeshiftContent, jscodeshiftContentNew, transformModule;
     return _regenerator.default.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -160,15 +160,20 @@ var runTransform = /*#__PURE__*/function () {
           }
         case 9:
           logger.log(_chalk.default.green("Transforming files matching these extensions '".concat(_chalk.default.bold(flags.extensions), "'...")));
-          transformPath = (0, _transforms.getTransformPath)(transform);
+          transformPath = (0, _transforms.getTransformPath)(transform); // Split the ignorePattern by '|' and add each as a separate --ignore-pattern
+          ignorePatterns = flags.ignorePattern.split('|').filter(Boolean);
+          ignoreArgs = ignorePatterns.map(function (pattern) {
+            return "--ignore-pattern=".concat(pattern);
+          });
           args = Object.keys(flags).reduce(function (acc, key) {
             if (!['transform', 'parser', 'extensions', 'ignorePattern', 'logger', 'packages', 'sinceRef', 'preset', 'failOnError'].includes(key)) {
               acc.unshift("--".concat(key, "=").concat(flags[key]));
             }
             return acc;
-          }, ["--transform=".concat(transformPath), "--ignore-pattern=".concat(flags.ignorePattern), "--parser=".concat(flags.parser), "--extensions=".concat(flags.extensions),
+          }, ["--transform=".concat(transformPath)].concat((0, _toConsumableArray2.default)(ignoreArgs), [// Spread the ignoreArgs array here
+          "--parser=".concat(flags.parser), "--extensions=".concat(flags.extensions),
           // Limit CPUs to 8 to prevent issues when running on CI with a large amount of cpus
-          '--cpus=8'].concat((0, _toConsumableArray2.default)(codemodDirs)));
+          '--cpus=8'], (0, _toConsumableArray2.default)(codemodDirs)));
           if (flags.failOnError) {
             args.unshift('--fail-on-error');
           }
@@ -186,24 +191,24 @@ var runTransform = /*#__PURE__*/function () {
             console.warn("Error loading transform module: ".concat(transformPath, ". Skipping lifecycle hooks."));
           }
           if (!transformModule) {
-            _context3.next = 20;
+            _context3.next = 22;
             break;
           }
-          _context3.next = 20;
-          return processLifecycleHook('beforeAll', transformModule, logger, transform, flags);
-        case 20:
           _context3.next = 22;
+          return processLifecycleHook('beforeAll', transformModule, logger, transform, flags);
+        case 22:
+          _context3.next = 24;
           return (0, _projectorSpawn.default)(jscodeshift, args, {
             stdio: 'inherit'
           });
-        case 22:
+        case 24:
           if (!transformModule) {
-            _context3.next = 25;
+            _context3.next = 27;
             break;
           }
-          _context3.next = 25;
+          _context3.next = 27;
           return processLifecycleHook('afterAll', transformModule, logger, transform, flags);
-        case 25:
+        case 27:
         case "end":
           return _context3.stop();
       }
@@ -309,7 +314,7 @@ var defaultFlags = {
   ignorePattern: 'node_modules',
   logger: console
 };
-function processLifecycleHook(_x9, _x10, _x11, _x12, _x13) {
+function processLifecycleHook(_x9, _x0, _x1, _x10, _x11) {
   return _processLifecycleHook.apply(this, arguments);
 }
 function _processLifecycleHook() {
@@ -341,7 +346,7 @@ function _processLifecycleHook() {
   }));
   return _processLifecycleHook.apply(this, arguments);
 }
-function main(_x14, _x15) {
+function main(_x12, _x13) {
   return _main.apply(this, arguments);
 }
 function _main() {
@@ -357,7 +362,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context6.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.27.4", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.28.1", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
           logger.log(_chalk.default.bgBlue(_chalk.default.black("\uD83D\uDCDA Atlassian-Frontend codemod library @ ".concat(_PACKAGE_VERSION_, " \uD83D\uDCDA"))));
           if (packages && packages.length > 0) {
             logger.log(_chalk.default.gray("Searching for codemods for newer versions of the following packages: ".concat(packages.map(function (pkg) {

package/dist/cjs/presets/remove-token-fallbacks/remove-token-fallbacks.js

@@ -9,6 +9,7 @@ exports.beforeAll = beforeAll;
 exports.default = transformer;
 exports.parser = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _child_process = require("child_process");
@@ -19,13 +20,15 @@ var _utils = require("@hypermod/utils");
 var _findRoot = require("@manypkg/find-root");
 var _chalk = _interopRequireDefault(require("chalk"));
 var _allTokens = require("./utils/all-tokens");
+var _chunk = require("./utils/chunk");
 var _getTeamInfo = require("./utils/get-team-info");
 var _removeUnusedImports = require("./utils/remove-unused-imports");
 var _removeUnusedVariables = require("./utils/remove-unused-variables");
 var _reporter = require("./utils/reporter");
 var _tokenProcessor = require("./utils/token-processor");
-/* eslint-disable no-console */
-
+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; } /* eslint-disable no-console */
 var execAsync = (0, _util.promisify)(_child_process.exec);
 
 /**
@@ -41,6 +44,14 @@ var execAsync = (0, _util.promisify)(_child_process.exec);
  *   @param {boolean} [options.useLegacyColorTheme] - If true, uses the legacy theme for color token mapping.
  *   @param {string} [options.reportFolder] - Directory path to output transformation reports. Reports will be generated only if this option is provided.
  *   @param {boolean} [options.dry] - If true, performs a dry run without modifying the files.
+ *   @param {string} [options.skipTokens] - A comma-separated list of token prefixes to exempt from automatic fallback removal. By default, 'border' tokens are always included in this list. Whether fallbacks for these tokens are removed when they exactly match depends on the preserveSkippedFallbacks option.
+ *   @param {boolean} [options.preserveSkippedFallbacks] - If true, fallbacks for skipped tokens will never be removed, even if they exactly match the token value. If false (default), fallbacks for skipped tokens will be removed if they exactly match.
+ *   @param {boolean} [options.skipEslint] - If true, skips running ESLint on modified files after transformation.
+ *   @param {boolean} [options.skipPrettier] - If true, skips running Prettier on modified files after transformation.
+ *   @param {number} [options.colorDifferenceThreshold] - The maximum allowed difference for color tokens to be considered acceptable for removal. Default is 15.
+ *   @param {number} [options.spaceDifferenceThreshold] - The maximum allowed percentage difference for space tokens to be considered acceptable for removal. Default is 0.
+ *   @param {number} [options.numericDifferenceThreshold] - The maximum allowed percentage difference for numeric tokens to be considered acceptable for removal. Default is 0.
+ *   @param {number} [options.borderDifferenceThreshold] - The maximum allowed percentage difference for border tokens to be considered acceptable for removal. Default is 0.
  *
  * @returns {Promise<string>} A promise that resolves to the transformed source code as a string.
  */
@@ -72,6 +83,32 @@ function _transformer() {
           };
           if (options.verbose) {
             console.log(_chalk.default.yellow("Using ".concat(options.useLegacyColorTheme ? 'legacy light' : 'light', " theme.")));
+            if (options.skipTokens) {
+              console.log(_chalk.default.yellow("Auto fallback exemptions active for: ".concat(options.skipTokens)));
+            }
+            if (options.preserveSkippedFallbacks) {
+              console.log(_chalk.default.yellow("Preserving all fallbacks for skipped tokens, even if they match exactly."));
+            }
+            if (options.skipEslint) {
+              console.log(_chalk.default.yellow("Skipping ESLint post-processing."));
+            }
+            if (options.skipPrettier) {
+              console.log(_chalk.default.yellow("Skipping Prettier post-processing."));
+            }
+
+            // Log threshold values if they are set
+            if (options.colorDifferenceThreshold !== undefined) {
+              console.log(_chalk.default.yellow("Color difference threshold set to: ".concat(options.colorDifferenceThreshold)));
+            }
+            if (options.spaceDifferenceThreshold !== undefined) {
+              console.log(_chalk.default.yellow("Space difference threshold set to: ".concat(options.spaceDifferenceThreshold, "%")));
+            }
+            if (options.numericDifferenceThreshold !== undefined) {
+              console.log(_chalk.default.yellow("Numeric difference threshold set to: ".concat(options.numericDifferenceThreshold, "%")));
+            }
+            if (options.borderDifferenceThreshold !== undefined) {
+              console.log(_chalk.default.yellow("Border difference threshold set to: ".concat(options.borderDifferenceThreshold, "%")));
+            }
           }
           tokenMap = (0, _allTokens.getTokenMap)((_options$useLegacyCol = options.useLegacyColorTheme) !== null && _options$useLegacyCol !== void 0 ? _options$useLegacyCol : false);
           _context.next = 12;
@@ -92,35 +129,39 @@ function _transformer() {
         case 16:
           results = _context.sent;
           unusedVars = [];
-          if (results.some(function (result) {
+          if (!options.reportFolder) {
+            _context.next = 21;
+            break;
+          }
+          _context.next = 21;
+          return (0, _reporter.writeReports)(details, options.reportFolder);
+        case 21:
+          if (!results.some(function (result) {
             return result.fallbackRemoved;
           })) {
-            allImports = results.flatMap(function (result) {
-              var _result$resolvedImpor;
-              return (_result$resolvedImpor = result.resolvedImportDeclaration) !== null && _result$resolvedImpor !== void 0 ? _result$resolvedImpor : [];
-            });
-            allVars = results.flatMap(function (result) {
-              var _result$resolvedLocal;
-              return (_result$resolvedLocal = result.resolvedLocalVarDeclaration) !== null && _result$resolvedLocal !== void 0 ? _result$resolvedLocal : [];
-            });
-            unusedVars.push.apply(unusedVars, (0, _toConsumableArray2.default)(allVars));
-            if (allImports.length) {
-              if (options.verbose) {
-                console.log(_chalk.default.green("".concat(fileInfo.path, ": Some fallbacks were removed. Cleaning up ").concat(allImports.length, " imports.")));
-              }
-              (0, _removeUnusedImports.removeUnusedImports)(allImports, j);
+            _context.next = 35;
+            break;
+          }
+          allImports = results.flatMap(function (result) {
+            var _result$resolvedImpor;
+            return (_result$resolvedImpor = result.resolvedImportDeclaration) !== null && _result$resolvedImpor !== void 0 ? _result$resolvedImpor : [];
+          });
+          allVars = results.flatMap(function (result) {
+            var _result$resolvedLocal;
+            return (_result$resolvedLocal = result.resolvedLocalVarDeclaration) !== null && _result$resolvedLocal !== void 0 ? _result$resolvedLocal : [];
+          });
+          unusedVars.push.apply(unusedVars, (0, _toConsumableArray2.default)(allVars));
+          if (allImports.length) {
+            if (options.verbose) {
+              console.log(_chalk.default.green("".concat(fileInfo.path, ": Some fallbacks were removed. Cleaning up ").concat(allImports.length, " imports.")));
             }
+            (0, _removeUnusedImports.removeUnusedImports)(allImports, j);
           }
-          (0, _removeUnusedVariables.removeUnusedVariables)(unusedVars, j);
-          if (!options.reportFolder) {
-            _context.next = 23;
-            break;
+          if (unusedVars.length) {
+            (0, _removeUnusedVariables.removeUnusedVariables)(unusedVars, j);
           }
-          _context.next = 23;
-          return (0, _reporter.writeReports)(details, options.reportFolder);
-        case 23:
           if (!options.dry) {
-            _context.next = 28;
+            _context.next = 32;
             break;
           }
           if (options.verbose) {
@@ -128,9 +169,14 @@ function _transformer() {
           }
           // Return the unmodified source if dryRun is true
           return _context.abrupt("return", fileInfo.source);
-        case 28:
+        case 32:
           return _context.abrupt("return", source.toSource());
-        case 29:
+        case 33:
+          _context.next = 36;
+          break;
+        case 35:
+          return _context.abrupt("return", fileInfo.source);
+        case 36:
         case "end":
           return _context.stop();
       }
@@ -148,7 +194,7 @@ function beforeAll(_x4) {
 }
 /**
  * Function executed after all transformations to combine individual file reports into a comprehensive transformation report.
- * It also applies prettier to the affected files.
+ * It also applies prettier and eslint (to remove dangling suppressions) to the affected files.
  */
 function _beforeAll() {
   _beforeAll = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(options) {
@@ -174,7 +220,7 @@ function afterAll(_x5) {
 }
 function _afterAll() {
   _afterAll = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(options) {
-    var filesTxtPath, fileContent;
+    var filesTxtPath, fileContent, filePaths, firstFilePath, rootDir;
     return _regenerator.default.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -186,7 +232,7 @@ function _afterAll() {
           return (0, _reporter.combineReports)(options.reportFolder);
         case 3:
           if (!(options.reportFolder && !options.dry)) {
-            _context3.next = 19;
+            _context3.next = 35;
             break;
           }
           _context3.prev = 4;
@@ -196,30 +242,291 @@ function _afterAll() {
         case 8:
           fileContent = _context3.sent;
           if (!(fileContent.length > 0)) {
-            _context3.next = 14;
+            _context3.next = 30;
             break;
           }
-          console.log("Running prettier on files: ".concat(_chalk.default.magenta(fileContent)));
-          _context3.next = 13;
-          return execAsync("yarn prettier --write ".concat(fileContent));
-        case 13:
-          console.log(_chalk.default.green("Prettier was run successfully"));
+          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
+          _context3.next = 14;
+          return (0, _findRoot.findRoot)(_path.default.dirname(firstFilePath));
         case 14:
-          _context3.next = 19;
+          rootDir = _context3.sent;
+          console.log('Root directory:', rootDir);
+          _context3.next = 18;
+          return gitStage(filePaths, rootDir);
+        case 18:
+          if (options.skipEslint) {
+            _context3.next = 23;
+            break;
+          }
+          _context3.next = 21;
+          return runEslint(filePaths, rootDir);
+        case 21:
+          _context3.next = 24;
           break;
-        case 16:
-          _context3.prev = 16;
+        case 23:
+          if (options.verbose) {
+            console.log(_chalk.default.blue('Skipping ESLint post-processing as requested.'));
+          }
+        case 24:
+          if (options.skipPrettier) {
+            _context3.next = 29;
+            break;
+          }
+          _context3.next = 27;
+          return runPrettier(filePaths, rootDir);
+        case 27:
+          _context3.next = 30;
+          break;
+        case 29:
+          if (options.verbose) {
+            console.log(_chalk.default.blue('Skipping Prettier post-processing as requested.'));
+          }
+        case 30:
+          _context3.next = 35;
+          break;
+        case 32:
+          _context3.prev = 32;
           _context3.t0 = _context3["catch"](4);
           if (_context3.t0 instanceof Error) {
-            console.error(_chalk.default.red("Unexpected error running Prettier: ".concat(_context3.t0.message)));
+            console.error(_chalk.default.red("Unexpected error: ".concat(_context3.t0.message)));
           } else {
-            console.error(_chalk.default.red('An unknown error occurred while running Prettier.'));
+            console.error(_chalk.default.red('An unknown error occurred.'));
           }
-        case 19:
+        case 35:
         case "end":
           return _context3.stop();
       }
-    }, _callee3, null, [[4, 16]]);
+    }, _callee3, null, [[4, 32]]);
   }));
   return _afterAll.apply(this, arguments);
+}
+function gitStage(_x6, _x7) {
+  return _gitStage.apply(this, arguments);
+}
+function _gitStage() {
+  _gitStage = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(filePaths, cwd) {
+    var gitAddCommand, _yield$execAsync, gitAddStdout, gitAddStderr;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          gitAddCommand = "git add ".concat(filePaths.join(' '));
+          console.log("Executing command: ".concat(gitAddCommand));
+          _context4.next = 4;
+          return execAsync(gitAddCommand, {
+            cwd: cwd
+          });
+        case 4:
+          _yield$execAsync = _context4.sent;
+          gitAddStdout = _yield$execAsync.stdout;
+          gitAddStderr = _yield$execAsync.stderr;
+          if (gitAddStdout) {
+            console.log(_chalk.default.blue("Git add output:\n".concat(gitAddStdout)));
+          }
+          if (gitAddStderr) {
+            console.error(_chalk.default.yellow("Git add errors:\n".concat(gitAddStderr)));
+          }
+          console.log(_chalk.default.green("All changes have been staged."));
+        case 10:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _gitStage.apply(this, arguments);
+}
+function runPrettier(_x8, _x9) {
+  return _runPrettier.apply(this, arguments);
+}
+function _runPrettier() {
+  _runPrettier = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(filePaths, cwd) {
+    var prettierCommand, _yield$execAsync2, prettierStdout, prettierStderr;
+    return _regenerator.default.wrap(function _callee5$(_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          prettierCommand = "yarn prettier --write ".concat(filePaths.join(' '));
+          console.log("Executing command: ".concat(prettierCommand));
+          _context5.next = 4;
+          return execAsync(prettierCommand, {
+            cwd: cwd
+          });
+        case 4:
+          _yield$execAsync2 = _context5.sent;
+          prettierStdout = _yield$execAsync2.stdout;
+          prettierStderr = _yield$execAsync2.stderr;
+          if (prettierStdout) {
+            console.log(_chalk.default.blue("Prettier output:\n".concat(prettierStdout)));
+          }
+          if (prettierStderr) {
+            console.error(_chalk.default.yellow("Prettier errors:\n".concat(prettierStderr)));
+          }
+          console.log(_chalk.default.green("Prettier was run successfully"));
+        case 10:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _runPrettier.apply(this, arguments);
+}
+function runEslint(_x0, _x1) {
+  return _runEslint.apply(this, arguments);
+}
+function _runEslint() {
+  _runEslint = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(filePaths, cwd) {
+    var fileChunks, totalChunks, _iterator, _step, _loop;
+    return _regenerator.default.wrap(function _callee7$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          fileChunks = (0, _chunk.chunkArray)(filePaths, 20);
+          totalChunks = fileChunks.length;
+          _iterator = _createForOfIteratorHelper(fileChunks.entries());
+          _context9.prev = 3;
+          _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
+            var _step$value, chunkIndex, fileChunk, eslintCommand, result, stdout, stderr, smallerChunks, totalSmallerChunks, _iterator2, _step2, _loop2;
+            return _regenerator.default.wrap(function _loop$(_context8) {
+              while (1) switch (_context8.prev = _context8.next) {
+                case 0:
+                  _step$value = (0, _slicedToArray2.default)(_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));
+                  _context8.prev = 3;
+                  _context8.next = 6;
+                  return execAsync(eslintCommand, {
+                    cwd: cwd
+                  });
+                case 6:
+                  result = _context8.sent;
+                  stdout = result.stdout, stderr = result.stderr;
+                  if (stdout) {
+                    console.log(_chalk.default.blue("ESLint output for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ":\n").concat(stdout)));
+                  }
+                  if (stderr) {
+                    console.error(_chalk.default.yellow("ESLint errors for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ":\n").concat(stderr)));
+                  }
+                  _context8.next = 34;
+                  break;
+                case 12:
+                  _context8.prev = 12;
+                  _context8.t0 = _context8["catch"](3);
+                  console.error(_chalk.default.red("Error running ESLint on chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ": ").concat(_context8.t0)));
+
+                  // Retry each file individually
+                  console.log(_chalk.default.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 = (0, _chunk.chunkArray)(fileChunk, 5);
+                  totalSmallerChunks = smallerChunks.length;
+                  _iterator2 = _createForOfIteratorHelper(smallerChunks.entries());
+                  _context8.prev = 19;
+                  _loop2 = /*#__PURE__*/_regenerator.default.mark(function _loop2() {
+                    var _step2$value, smallChunkIndex, smallerChunk;
+                    return _regenerator.default.wrap(function _loop2$(_context7) {
+                      while (1) switch (_context7.prev = _context7.next) {
+                        case 0:
+                          _step2$value = (0, _slicedToArray2.default)(_step2.value, 2), smallChunkIndex = _step2$value[0], smallerChunk = _step2$value[1];
+                          _context7.next = 3;
+                          return Promise.all(smallerChunk.map( /*#__PURE__*/function () {
+                            var _ref2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(file) {
+                              var individualEslintCommand, _result, _stdout, _stderr;
+                              return _regenerator.default.wrap(function _callee6$(_context6) {
+                                while (1) switch (_context6.prev = _context6.next) {
+                                  case 0:
+                                    _context6.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));
+                                    _context6.next = 5;
+                                    return execAsync(individualEslintCommand, {
+                                      cwd: cwd
+                                    });
+                                  case 5:
+                                    _result = _context6.sent;
+                                    _stdout = _result.stdout, _stderr = _result.stderr;
+                                    if (_stdout) {
+                                      console.log(_chalk.default.blue("ESLint output for file ".concat(file, " in small chunk ").concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ":\n").concat(_stdout)));
+                                    }
+                                    if (_stderr) {
+                                      console.error(_chalk.default.yellow("ESLint errors for file ".concat(file, " in small chunk ").concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ":\n").concat(_stderr)));
+                                    }
+                                    _context6.next = 14;
+                                    break;
+                                  case 11:
+                                    _context6.prev = 11;
+                                    _context6.t0 = _context6["catch"](0);
+                                    console.error(_chalk.default.red("Error running ESLint on file ".concat(file, " in small chunk ").concat(smallChunkIndex + 1, " of ").concat(totalSmallerChunks, ": ").concat(_context6.t0)));
+                                  case 14:
+                                  case "end":
+                                    return _context6.stop();
+                                }
+                              }, _callee6, null, [[0, 11]]);
+                            }));
+                            return function (_x10) {
+                              return _ref2.apply(this, arguments);
+                            };
+                          }()));
+                        case 3:
+                        case "end":
+                          return _context7.stop();
+                      }
+                    }, _loop2);
+                  });
+                  _iterator2.s();
+                case 22:
+                  if ((_step2 = _iterator2.n()).done) {
+                    _context8.next = 26;
+                    break;
+                  }
+                  return _context8.delegateYield(_loop2(), "t1", 24);
+                case 24:
+                  _context8.next = 22;
+                  break;
+                case 26:
+                  _context8.next = 31;
+                  break;
+                case 28:
+                  _context8.prev = 28;
+                  _context8.t2 = _context8["catch"](19);
+                  _iterator2.e(_context8.t2);
+                case 31:
+                  _context8.prev = 31;
+                  _iterator2.f();
+                  return _context8.finish(31);
+                case 34:
+                  console.log(_chalk.default.green("Finished running ESLint for chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ".")));
+                case 35:
+                case "end":
+                  return _context8.stop();
+              }
+            }, _loop, null, [[3, 12], [19, 28, 31, 34]]);
+          });
+          _iterator.s();
+        case 6:
+          if ((_step = _iterator.n()).done) {
+            _context9.next = 10;
+            break;
+          }
+          return _context9.delegateYield(_loop(), "t0", 8);
+        case 8:
+          _context9.next = 6;
+          break;
+        case 10:
+          _context9.next = 15;
+          break;
+        case 12:
+          _context9.prev = 12;
+          _context9.t1 = _context9["catch"](3);
+          _iterator.e(_context9.t1);
+        case 15:
+          _context9.prev = 15;
+          _iterator.f();
+          return _context9.finish(15);
+        case 18:
+          console.log(_chalk.default.green("ESLint was run on all files successfully"));
+        case 19:
+        case "end":
+          return _context9.stop();
+      }
+    }, _callee7, null, [[3, 12, 15, 18]]);
+  }));
+  return _runEslint.apply(this, arguments);
 }

package/dist/cjs/presets/remove-token-fallbacks/utils/chunk.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chunkArray = void 0;
+// Utility function to split an array into chunks
+var chunkArray = exports.chunkArray = function chunkArray(array, chunkSize) {
+  var result = [];
+  for (var i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};