@atlaskit/codemod-cli 0.27.4 → 0.28.0

package/dist/es2019/presets/remove-token-fallbacks/utils/token-processor.js

@@ -67,7 +67,10 @@ export class TokenProcessor {
         resolvedLocalVarDeclaration: undefined
       };
     }
-    const isSkipped = tokenKey.startsWith('elevation.shadow') || tokenKey.startsWith('font.body') || tokenKey.startsWith('font.heading');
+    const isSkipped = false;
+    // tokenKey.startsWith('elevation.shadow') ||
+    // tokenKey.startsWith('font.body') ||
+    // tokenKey.startsWith('font.heading');
     const tokenValue = isSkipped ? '' : this.tokenMap[tokenKey];
     this.logVerbose(`Token value from tokenMap: ${chalk.magenta(tokenValue)} for key: ${chalk.yellow(tokenKey)}`);
     const {
@@ -103,7 +106,8 @@ export class TokenProcessor {
     let fallbackRemoved = false;
     let importDeclaration;
     let localVarDeclaration;
-    if (areEqual || isAcceptableDifference || this.options.forceUpdate) {
+    const isBorderToken = tokenKey.startsWith('border');
+    if (areEqual || (isAcceptableDifference || this.options.forceUpdate) && !isBorderToken) {
       this.log(chalk.green(areEqual ? 'Token value and fallback value are equal, removing fallback' : 'Token value and fallback value are within acceptable difference threshold, removing fallback'));
       args.pop();
       this.details.replaced.push(logData);
@@ -111,7 +115,7 @@ export class TokenProcessor {
       importDeclaration = resolvedImportDeclaration;
       localVarDeclaration = resolvedLocalVarDeclaration;
     } else {
-      const message = normalizedFallbackValue === undefined ? `Fallback value could not be resolved` : `Values mismatched significantly`;
+      const message = isBorderToken ? 'Skip modifying border token' : normalizedFallbackValue === undefined ? `Fallback value could not be resolved` : `Values mismatched significantly`;
       this.logError(message);
       if (this.options.addEslintComments) {
         addOrUpdateEslintIgnoreComment(this.j, tokenValue, fallbackValue, callPath);
@@ -211,6 +215,56 @@ export class TokenProcessor {
     let objectName;
     let propertyName;
     let fallbackValue;
+    let resolvedImportDeclaration;
+    let resolvedLocalVarDeclaration;
+
+    // Function to get full member expression path as string
+    const getFullMemberPath = node => {
+      if (node.type === 'Identifier') {
+        return node.name;
+      } else if (node.type === 'MemberExpression') {
+        return `${getFullMemberPath(node.object)}.${node.property.type === 'Identifier' ? node.property.name : ''}`;
+      }
+      return '';
+    };
+    const fullMemberPath = getFullMemberPath(fallbackValueNode);
+
+    // Detect long member expression paths
+    const pathSegments = fullMemberPath.split('.');
+    if (pathSegments.length > 2) {
+      this.logVerbose(`Detected long member expression: ${chalk.yellow(fullMemberPath)}. Just resolving import or local variable declaration.`);
+
+      // Find the import statement or local variable for the top-level object
+      objectName = pathSegments[0];
+
+      // Check if it's a local variable
+      const localVarDeclaration = this.source.find(this.j.VariableDeclarator, {
+        id: {
+          name: objectName
+        }
+      }).at(0);
+      if (localVarDeclaration.size()) {
+        resolvedLocalVarDeclaration = localVarDeclaration.paths()[0];
+        this.logVerbose(`Resolved local variable declaration for: ${chalk.yellow(objectName)}`);
+      } else {
+        // Search for import declaration
+        const importDeclaration = this.source.find(this.j.ImportDeclaration).filter(this.createImportFilter(objectName)).at(0);
+        if (importDeclaration.size()) {
+          resolvedImportDeclaration = importDeclaration.paths()[0];
+          this.logVerbose(`Resolved import declaration for: ${chalk.yellow(objectName)}`);
+        } else {
+          this.logError(`Could not resolve import or local variable for: ${chalk.yellow(objectName)}`);
+        }
+      }
+      return {
+        rawFallbackValue: fullMemberPath,
+        fallbackValue: undefined,
+        resolvedImportDeclaration,
+        resolvedLocalVarDeclaration
+      };
+    }
+
+    // Existing logic for member expressions with shorter paths
     if (fallbackValueNode.object.type === 'Identifier') {
       objectName = fallbackValueNode.object.name;
     }
@@ -230,7 +284,6 @@ export class TokenProcessor {
     }
     const rawFallbackValue = `${objectName}.${propertyName}`;
     this.logVerbose(`Fallback is a member expression: ${chalk.yellow(rawFallbackValue)}, attempting to resolve...`);
-    let resolvedImportDeclaration;
 
     // Find the import statement for the object
     const importDeclaration = this.source.find(this.j.ImportDeclaration).filter(this.createImportFilter(objectName)).at(0);
@@ -253,22 +306,45 @@ export class TokenProcessor {
   }
   async processFallbackAsTemplateLiteral(fallbackValueNode) {
     const expressions = fallbackValueNode.expressions;
+    const quasis = fallbackValueNode.quasis;
+    let resolvedImportDeclaration;
+    let resolvedLocalVarDeclaration;
     let rawFallbackValue = '';
     let fallbackValue;
-    const quasis = fallbackValueNode.quasis;
     if (expressions.length !== 1 || quasis.length !== 2) {
       this.logError(`Unsupported template literal structure`);
+
+      // Attempt to resolve any imports or local variables used in expressions
+      for (const expression of expressions) {
+        if (expression.type === 'Identifier') {
+          const result = await this.processFallbackAsIdentifier(expression);
+          if (result.resolvedImportDeclaration) {
+            resolvedImportDeclaration = result.resolvedImportDeclaration;
+          }
+          if (result.resolvedLocalVarDeclaration) {
+            resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
+          }
+        } else if (expression.type === 'MemberExpression') {
+          const result = await this.processFallbackAsMemberExpression(expression);
+          if (result.resolvedImportDeclaration) {
+            resolvedImportDeclaration = result.resolvedImportDeclaration;
+          }
+          if (result.resolvedLocalVarDeclaration) {
+            resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
+          }
+        }
+      }
       return {
         rawFallbackValue,
         fallbackValue,
-        resolvedImportDeclaration: undefined,
-        resolvedLocalVarDeclaration: undefined
+        resolvedImportDeclaration,
+        resolvedLocalVarDeclaration
       };
     }
+
+    // Handle supported template literal structures as before
     let exprValue;
     const expression = expressions[0];
-    let resolvedImportDeclaration;
-    let resolvedLocalVarDeclaration;
     if (expression.type === 'Identifier') {
       const result = await this.processFallbackAsIdentifier(expression);
       exprValue = result.fallbackValue;

package/dist/esm/main.js

@@ -128,7 +128,7 @@ var resolveTransform = /*#__PURE__*/function () {
 }();
 var runTransform = /*#__PURE__*/function () {
   var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.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 _regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -153,15 +153,20 @@ var runTransform = /*#__PURE__*/function () {
           }
         case 9:
           logger.log(chalk.green("Transforming files matching these extensions '".concat(chalk.bold(flags.extensions), "'...")));
-          transformPath = getTransformPath(transform);
+          transformPath = 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(_toConsumableArray(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(_toConsumableArray(codemodDirs)));
+          '--cpus=8'], _toConsumableArray(codemodDirs)));
           if (flags.failOnError) {
             args.unshift('--fail-on-error');
           }
@@ -179,24 +184,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 spawn(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();
       }
@@ -350,7 +355,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.0", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
           logger.log(chalk.bgBlue(chalk.black("\uD83D\uDCDA Atlassian-Frontend codemod library @ ".concat(_PACKAGE_VERSION_, " \uD83D\uDCDA"))));
           if (packages && packages.length > 0) {
             logger.log(chalk.gray("Searching for codemods for newer versions of the following packages: ".concat(packages.map(function (pkg) {

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

@@ -1,5 +1,9 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 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';
@@ -10,6 +14,7 @@ import { hasImportDeclaration } from '@hypermod/utils';
 import { findRoot } from '@manypkg/find-root';
 import chalk from 'chalk';
 import { getTokenMap } from './utils/all-tokens';
+import { chunkArray } from './utils/chunk';
 import { getTeamInfo } from './utils/get-team-info';
 import { removeUnusedImports } from './utils/remove-unused-imports';
 import { removeUnusedVariables } from './utils/remove-unused-variables';
@@ -81,35 +86,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 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, _toConsumableArray(allVars));
-            if (allImports.length) {
-              if (options.verbose) {
-                console.log(chalk.green("".concat(fileInfo.path, ": Some fallbacks were removed. Cleaning up ").concat(allImports.length, " imports.")));
-              }
-              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, _toConsumableArray(allVars));
+          if (allImports.length) {
+            if (options.verbose) {
+              console.log(chalk.green("".concat(fileInfo.path, ": Some fallbacks were removed. Cleaning up ").concat(allImports.length, " imports.")));
             }
+            removeUnusedImports(allImports, j);
           }
-          removeUnusedVariables(unusedVars, j);
-          if (!options.reportFolder) {
-            _context.next = 23;
-            break;
+          if (unusedVars.length) {
+            removeUnusedVariables(unusedVars, j);
           }
-          _context.next = 23;
-          return writeReports(details, options.reportFolder);
-        case 23:
           if (!options.dry) {
-            _context.next = 28;
+            _context.next = 32;
             break;
           }
           if (options.verbose) {
@@ -117,9 +126,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();
       }
@@ -138,7 +152,7 @@ export 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 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(options) {
@@ -164,7 +178,7 @@ export function afterAll(_x5) {
 }
 function _afterAll() {
   _afterAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
-    var filesTxtPath, fileContent;
+    var filesTxtPath, fileContent, filePaths, firstFilePath, rootDir;
     return _regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -176,7 +190,7 @@ function _afterAll() {
           return combineReports(options.reportFolder);
         case 3:
           if (!(options.reportFolder && !options.dry)) {
-            _context3.next = 19;
+            _context3.next = 27;
             break;
           }
           _context3.prev = 4;
@@ -186,30 +200,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.magenta(fileContent)));
-          _context3.next = 13;
-          return execAsync("yarn prettier --write ".concat(fileContent));
-        case 13:
-          console.log(chalk.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 findRoot(path.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.red("Unexpected error running Prettier: ".concat(_context3.t0.message)));
+            console.error(chalk.red("Unexpected error: ".concat(_context3.t0.message)));
           } else {
-            console.error(chalk.red('An unknown error occurred while running Prettier.'));
+            console.error(chalk.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 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(filePaths, cwd) {
+    var gitAddCommand, _yield$execAsync, gitAddStdout, gitAddStderr;
+    return _regeneratorRuntime.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.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 _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _gitStage.apply(this, arguments);
+}
+function runPrettier(_x8, _x9) {
+  return _runPrettier.apply(this, arguments);
+}
+function _runPrettier() {
+  _runPrettier = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(filePaths, cwd) {
+    var prettierCommand, _yield$execAsync2, prettierStdout, prettierStderr;
+    return _regeneratorRuntime.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.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 _context5.stop();
+      }
+    }, _callee5);
+  }));
+  return _runPrettier.apply(this, arguments);
+}
+function runEslint(_x10, _x11) {
+  return _runEslint.apply(this, arguments);
+}
+function _runEslint() {
+  _runEslint = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(filePaths, cwd) {
+    var fileChunks, totalChunks, _iterator, _step, _loop;
+    return _regeneratorRuntime.wrap(function _callee7$(_context9) {
+      while (1) switch (_context9.prev = _context9.next) {
+        case 0:
+          fileChunks = chunkArray(filePaths, 20);
+          totalChunks = fileChunks.length;
+          _iterator = _createForOfIteratorHelper(fileChunks.entries());
+          _context9.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$(_context8) {
+              while (1) switch (_context8.prev = _context8.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));
+                  _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.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)));
+                  }
+                  _context8.next = 34;
+                  break;
+                case 12:
+                  _context8.prev = 12;
+                  _context8.t0 = _context8["catch"](3);
+                  console.error(chalk.red("Error running ESLint on chunk ".concat(chunkIndex + 1, " of ").concat(totalChunks, ": ").concat(_context8.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());
+                  _context8.prev = 19;
+                  _loop2 = /*#__PURE__*/_regeneratorRuntime.mark(function _loop2() {
+                    var _step2$value, smallChunkIndex, smallerChunk;
+                    return _regeneratorRuntime.wrap(function _loop2$(_context7) {
+                      while (1) switch (_context7.prev = _context7.next) {
+                        case 0:
+                          _step2$value = _slicedToArray(_step2.value, 2), smallChunkIndex = _step2$value[0], smallerChunk = _step2$value[1];
+                          _context7.next = 3;
+                          return Promise.all(smallerChunk.map( /*#__PURE__*/function () {
+                            var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(file) {
+                              var individualEslintCommand, _result, _stdout, _stderr;
+                              return _regeneratorRuntime.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.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)));
+                                    }
+                                    _context6.next = 14;
+                                    break;
+                                  case 11:
+                                    _context6.prev = 11;
+                                    _context6.t0 = _context6["catch"](0);
+                                    console.error(chalk.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.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.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/esm/presets/remove-token-fallbacks/utils/chunk.js

@@ -0,0 +1,8 @@
+// Utility function to split an array into chunks
+export var 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/esm/presets/remove-token-fallbacks/utils/normalize-values.js

@@ -3,9 +3,10 @@ import chalk from 'chalk';
 import { colorToHex, compareHex, isValidColor } from './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;
 export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
   var tokenLogValue;
   var fallbackLogValue;
@@ -29,13 +30,13 @@ export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
       difference = 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;