@atlaskit/codemod-cli 0.27.3 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/codemod-cli
 
+## 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
+
+- [#127093](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/127093)
+  [`1378ea7a99ce1`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/1378ea7a99ce1) -
+  Upgrades `jscodeshift` to handle generics properly.
+- Updated dependencies
+
 ## 0.27.3
 
 ### 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();
       }
@@ -357,7 +362,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context6.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.27.3", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.28.0", _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);
 
 /**
@@ -92,35 +95,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 +135,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 +160,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 +186,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 +198,7 @@ function _afterAll() {
           return (0, _reporter.combineReports)(options.reportFolder);
         case 3:
           if (!(options.reportFolder && !options.dry)) {
-            _context3.next = 19;
+            _context3.next = 27;
             break;
           }
           _context3.prev = 4;
@@ -196,30 +208,269 @@ function _afterAll() {
         case 8:
           fileContent = _context3.sent;
           if (!(fileContent.length > 0)) {
-            _context3.next = 14;
+            _context3.next = 22;
             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:
+          _context3.next = 20;
+          return runEslint(filePaths, rootDir);
+        case 20:
+          _context3.next = 22;
+          return runPrettier(filePaths, rootDir);
+        case 22:
+          _context3.next = 27;
           break;
-        case 16:
-          _context3.prev = 16;
+        case 24:
+          _context3.prev = 24;
           _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 27:
         case "end":
           return _context3.stop();
       }
-    }, _callee3, null, [[4, 16]]);
+    }, _callee3, null, [[4, 24]]);
   }));
   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(_x10, _x11) {
+  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 (_x12) {
+                              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;
+};

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

@@ -9,9 +9,10 @@ var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/sli
 var _chalk = _interopRequireDefault(require("chalk"));
 var _colorUtils = require("./color-utils");
 // so far allowing to remove only exact matches in values. Can be increased to auto-remove fallbacks with similar values
-var ACCEPTABLE_COLOR_DIFFERENCE = 0;
+var ACCEPTABLE_COLOR_DIFFERENCE = 15;
 var ACCEPTABLE_SPACE_DIFFERENCE = 0;
 var ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
+var ACCEPTABLE_BORDER_DIFFERENCE = 0;
 function normalizeValues(tokenKey, tokenValue, fallbackValue) {
   var tokenLogValue;
   var fallbackLogValue;
@@ -35,13 +36,13 @@ function normalizeValues(tokenKey, tokenValue, fallbackValue) {
       difference = (0, _colorUtils.compareHex)(normalizedTokenValue, normalizedFallbackValue);
       isAcceptableDifference = difference <= ACCEPTABLE_COLOR_DIFFERENCE;
     }
-  } else if (lowerCaseTokenKey.startsWith('space')) {
+  } else if (lowerCaseTokenKey.startsWith('space') || lowerCaseTokenKey.startsWith('border')) {
     var tokenValueInPx = tokenValue ? convertToPx(tokenValue) : undefined;
     var fallbackValueInPx = fallbackValue ? convertToPx(fallbackValue) : undefined;
     if (tokenValueInPx !== undefined && fallbackValueInPx !== undefined) {
       var maxVal = Math.max(tokenValueInPx, fallbackValueInPx);
       difference = Math.abs(tokenValueInPx - fallbackValueInPx) / maxVal * 100;
-      isAcceptableDifference = difference <= ACCEPTABLE_SPACE_DIFFERENCE;
+      isAcceptableDifference = difference <= (lowerCaseTokenKey.startsWith('space') ? ACCEPTABLE_SPACE_DIFFERENCE : ACCEPTABLE_BORDER_DIFFERENCE);
     }
     // Log the normalized values
     normalizedTokenValue = tokenValue;

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

@@ -46,12 +46,12 @@ function removeUnusedImports(importDeclarations, j) {
   };
   var processImportDeclaration = function processImportDeclaration(importDeclaration) {
     var _importDeclaration$va, _importDeclaration$va2;
-    if (((_importDeclaration$va = importDeclaration.value.specifiers) === null || _importDeclaration$va === void 0 ? void 0 : _importDeclaration$va.length) === 0) {
+    if (((_importDeclaration$va = importDeclaration.value) === null || _importDeclaration$va === void 0 || (_importDeclaration$va = _importDeclaration$va.specifiers) === null || _importDeclaration$va === void 0 ? void 0 : _importDeclaration$va.length) === 0) {
       return false;
     }
     var hadUnusedDefaultImport = removeUnusedDefaultImport(importDeclaration);
     var hadUnusedNonDefaultImports = removeUnusedNonDefaultImports(importDeclaration);
-    if (((_importDeclaration$va2 = importDeclaration.value.specifiers) === null || _importDeclaration$va2 === void 0 ? void 0 : _importDeclaration$va2.length) === 0) {
+    if (((_importDeclaration$va2 = importDeclaration.value) === null || _importDeclaration$va2 === void 0 || (_importDeclaration$va2 = _importDeclaration$va2.specifiers) === null || _importDeclaration$va2 === void 0 ? void 0 : _importDeclaration$va2.length) === 0) {
       j(importDeclaration).remove();
       return true;
     }

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

@@ -82,41 +82,47 @@ function _clearFolder() {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
           console.log('Clearing report folder:', reportFolder);
+          // Create the folder if it doesn't exist
           _context3.next = 3;
-          return _promises.default.readdir(reportFolder);
+          return _promises.default.mkdir(reportFolder, {
+            recursive: true
+          });
         case 3:
+          _context3.next = 5;
+          return _promises.default.readdir(reportFolder);
+        case 5:
           filesToDelete = _context3.sent;
           _iterator = _createForOfIteratorHelper(filesToDelete);
-          _context3.prev = 5;
+          _context3.prev = 7;
           _iterator.s();
-        case 7:
+        case 9:
           if ((_step = _iterator.n()).done) {
-            _context3.next = 14;
+            _context3.next = 16;
             break;
           }
           file = _step.value;
           filePath = _path.default.join(reportFolder, file);
-          _context3.next = 12;
+          _context3.next = 14;
           return _promises.default.unlink(filePath);
-        case 12:
-          _context3.next = 7;
-          break;
         case 14:
-          _context3.next = 19;
+          _context3.next = 9;
           break;
         case 16:
-          _context3.prev = 16;
-          _context3.t0 = _context3["catch"](5);
+          _context3.next = 21;
+          break;
+        case 18:
+          _context3.prev = 18;
+          _context3.t0 = _context3["catch"](7);
           _iterator.e(_context3.t0);
-        case 19:
-          _context3.prev = 19;
+        case 21:
+          _context3.prev = 21;
           _iterator.f();
-          return _context3.finish(19);
-        case 22:
+          return _context3.finish(21);
+        case 24:
         case "end":
           return _context3.stop();
       }
-    }, _callee3, null, [[5, 16, 19, 22]]);
+    }, _callee3, null, [[7, 18, 21, 24]]);
   }));
   return _clearFolder.apply(this, arguments);
 }
@@ -125,16 +131,17 @@ function saveFilePaths(_x5, _x6) {
 }
 function _saveFilePaths() {
   _saveFilePaths = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(reportFolder, files) {
-    var filesTxtPath;
+    var filesTxtPath, sortedFiles;
     return _regenerator.default.wrap(function _callee4$(_context4) {
       while (1) switch (_context4.prev = _context4.next) {
         case 0:
           filesTxtPath = _path.default.join(reportFolder, 'files.txt');
-          _context4.next = 3;
-          return _promises.default.writeFile(filesTxtPath, Array.from(files).map(function (filePath) {
+          sortedFiles = Array.from(files).sort(); // Sort the file paths alphabetically
+          _context4.next = 4;
+          return _promises.default.writeFile(filesTxtPath, sortedFiles.map(function (filePath) {
             return "\"".concat(filePath, "\"");
-          }).join(' '), 'utf-8');
-        case 3:
+          }).join('\n'), 'utf-8');
+        case 4:
         case "end":
           return _context4.stop();
       }