@atlaskit/codemod-cli 0.27.3 → 0.28.0

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

@@ -94,7 +94,7 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
     value: function () {
       var _processSingleToken = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(callPath) {
         var _callPath$node$loc2;
-        var args, line, tokenKey, isSkipped, tokenValue, _ref, rawFallbackValue, fallbackValue, resolvedImportDeclaration, resolvedLocalVarDeclaration, _normalizeValues, difference, isAcceptableDifference, tokenLogValue, fallbackLogValue, normalizedTokenValue, normalizedFallbackValue, areEqual, logData, fallbackRemoved, importDeclaration, localVarDeclaration, message;
+        var args, line, tokenKey, isSkipped, tokenValue, _ref, rawFallbackValue, fallbackValue, resolvedImportDeclaration, resolvedLocalVarDeclaration, _normalizeValues, difference, isAcceptableDifference, tokenLogValue, fallbackLogValue, normalizedTokenValue, normalizedFallbackValue, areEqual, logData, fallbackRemoved, importDeclaration, localVarDeclaration, isBorderToken, message;
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -124,7 +124,9 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 resolvedLocalVarDeclaration: undefined
               });
             case 8:
-              isSkipped = tokenKey.startsWith('elevation.shadow') || tokenKey.startsWith('font.body') || tokenKey.startsWith('font.heading');
+              isSkipped = false; // tokenKey.startsWith('elevation.shadow') ||
+              // tokenKey.startsWith('font.body') ||
+              // tokenKey.startsWith('font.heading');
               tokenValue = isSkipped ? '' : this.tokenMap[tokenKey];
               this.logVerbose("Token value from tokenMap: ".concat(_chalk.default.magenta(tokenValue), " for key: ").concat(_chalk.default.yellow(tokenKey)));
               if (!isSkipped) {
@@ -163,7 +165,8 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 difference: difference
               };
               fallbackRemoved = false;
-              if (areEqual || isAcceptableDifference || this.options.forceUpdate) {
+              isBorderToken = tokenKey.startsWith('border');
+              if (areEqual || (isAcceptableDifference || this.options.forceUpdate) && !isBorderToken) {
                 this.log(_chalk.default.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);
@@ -171,7 +174,7 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 importDeclaration = resolvedImportDeclaration;
                 localVarDeclaration = resolvedLocalVarDeclaration;
               } else {
-                message = normalizedFallbackValue === undefined ? "Fallback value could not be resolved" : "Values mismatched significantly";
+                message = isBorderToken ? 'Skip modifying border token' : normalizedFallbackValue === undefined ? "Fallback value could not be resolved" : "Values mismatched significantly";
                 this.logError(message);
                 if (this.options.addEslintComments) {
                   (0, _updateComments.addOrUpdateEslintIgnoreComment)(this.j, tokenValue, fallbackValue, callPath);
@@ -185,7 +188,7 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 resolvedImportDeclaration: importDeclaration,
                 resolvedLocalVarDeclaration: localVarDeclaration
               });
-            case 30:
+            case 31:
             case "end":
               return _context2.stop();
           }
@@ -328,10 +331,57 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
     key: "processFallbackAsMemberExpression",
     value: function () {
       var _processFallbackAsMemberExpression = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(fallbackValueNode) {
-        var objectName, propertyName, fallbackValue, rawFallbackValue, resolvedImportDeclaration, importDeclaration, importSource;
+        var objectName, propertyName, fallbackValue, resolvedImportDeclaration, resolvedLocalVarDeclaration, _getFullMemberPath, fullMemberPath, pathSegments, localVarDeclaration, _importDeclaration, rawFallbackValue, importDeclaration, importSource;
         return _regenerator.default.wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
+              // Function to get full member expression path as string
+              _getFullMemberPath = function getFullMemberPath(node) {
+                if (node.type === 'Identifier') {
+                  return node.name;
+                } else if (node.type === 'MemberExpression') {
+                  return "".concat(_getFullMemberPath(node.object), ".").concat(node.property.type === 'Identifier' ? node.property.name : '');
+                }
+                return '';
+              };
+              fullMemberPath = _getFullMemberPath(fallbackValueNode); // Detect long member expression paths
+              pathSegments = fullMemberPath.split('.');
+              if (!(pathSegments.length > 2)) {
+                _context5.next = 9;
+                break;
+              }
+              this.logVerbose("Detected long member expression: ".concat(_chalk.default.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
+              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: ".concat(_chalk.default.yellow(objectName)));
+              } else {
+                // Search for import declaration
+                _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: ".concat(_chalk.default.yellow(objectName)));
+                } else {
+                  this.logError("Could not resolve import or local variable for: ".concat(_chalk.default.yellow(objectName)));
+                }
+              }
+              return _context5.abrupt("return", {
+                rawFallbackValue: fullMemberPath,
+                fallbackValue: undefined,
+                resolvedImportDeclaration: resolvedImportDeclaration,
+                resolvedLocalVarDeclaration: resolvedLocalVarDeclaration
+              });
+            case 9:
+              // Existing logic for member expressions with shorter paths
               if (fallbackValueNode.object.type === 'Identifier') {
                 objectName = fallbackValueNode.object.name;
               }
@@ -341,7 +391,7 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 propertyName = fallbackValueNode.property.value;
               }
               if (!(!objectName || !propertyName)) {
-                _context5.next = 5;
+                _context5.next = 14;
                 break;
               }
               this.logError("Could not determine object and property names from member expression: ".concat(_chalk.default.yellow(fallbackValueNode)));
@@ -351,36 +401,37 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 resolvedImportDeclaration: undefined,
                 resolvedLocalVarDeclaration: undefined
               });
-            case 5:
+            case 14:
               rawFallbackValue = "".concat(objectName, ".").concat(propertyName);
               this.logVerbose("Fallback is a member expression: ".concat(_chalk.default.yellow(rawFallbackValue), ", attempting to resolve..."));
+
               // Find the import statement for the object
               importDeclaration = this.source.find(this.j.ImportDeclaration).filter(this.createImportFilter(objectName)).at(0);
               if (!importDeclaration.size()) {
-                _context5.next = 16;
+                _context5.next = 25;
                 break;
               }
               importSource = importDeclaration.get().value.source.value;
-              _context5.next = 12;
+              _context5.next = 21;
               return this.resolveValueFromImport(this.rootDir, importSource, objectName, propertyName);
-            case 12:
+            case 21:
               fallbackValue = _context5.sent;
               if (fallbackValue !== undefined) {
                 resolvedImportDeclaration = importDeclaration.paths()[0];
                 this.logVerbose("Resolved fallback value from member expression: ".concat(_chalk.default.yellow(fallbackValue)));
               }
-              _context5.next = 17;
+              _context5.next = 26;
               break;
-            case 16:
+            case 25:
               this.logError("Could not find import for member expression: ".concat(_chalk.default.yellow(rawFallbackValue)));
-            case 17:
+            case 26:
               return _context5.abrupt("return", {
                 rawFallbackValue: rawFallbackValue,
                 fallbackValue: fallbackValue,
                 resolvedImportDeclaration: resolvedImportDeclaration,
                 resolvedLocalVarDeclaration: undefined
               });
-            case 18:
+            case 27:
             case "end":
               return _context5.stop();
           }
@@ -395,51 +446,108 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
     key: "processFallbackAsTemplateLiteral",
     value: function () {
       var _processFallbackAsTemplateLiteral = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(fallbackValueNode) {
-        var expressions, rawFallbackValue, fallbackValue, quasis, exprValue, expression, resolvedImportDeclaration, resolvedLocalVarDeclaration, result, _result;
+        var expressions, quasis, resolvedImportDeclaration, resolvedLocalVarDeclaration, rawFallbackValue, fallbackValue, _iterator, _step, _expression, result, _result, exprValue, expression, _result2, _result3;
         return _regenerator.default.wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
             case 0:
               expressions = fallbackValueNode.expressions;
-              rawFallbackValue = '';
               quasis = fallbackValueNode.quasis;
+              rawFallbackValue = '';
               if (!(expressions.length !== 1 || quasis.length !== 2)) {
-                _context6.next = 6;
+                _context6.next = 35;
                 break;
               }
               this.logError("Unsupported template literal structure");
+
+              // Attempt to resolve any imports or local variables used in expressions
+              _iterator = _createForOfIteratorHelper(expressions);
+              _context6.prev = 6;
+              _iterator.s();
+            case 8:
+              if ((_step = _iterator.n()).done) {
+                _context6.next = 26;
+                break;
+              }
+              _expression = _step.value;
+              if (!(_expression.type === 'Identifier')) {
+                _context6.next = 18;
+                break;
+              }
+              _context6.next = 13;
+              return this.processFallbackAsIdentifier(_expression);
+            case 13:
+              result = _context6.sent;
+              if (result.resolvedImportDeclaration) {
+                resolvedImportDeclaration = result.resolvedImportDeclaration;
+              }
+              if (result.resolvedLocalVarDeclaration) {
+                resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
+              }
+              _context6.next = 24;
+              break;
+            case 18:
+              if (!(_expression.type === 'MemberExpression')) {
+                _context6.next = 24;
+                break;
+              }
+              _context6.next = 21;
+              return this.processFallbackAsMemberExpression(_expression);
+            case 21:
+              _result = _context6.sent;
+              if (_result.resolvedImportDeclaration) {
+                resolvedImportDeclaration = _result.resolvedImportDeclaration;
+              }
+              if (_result.resolvedLocalVarDeclaration) {
+                resolvedLocalVarDeclaration = _result.resolvedLocalVarDeclaration;
+              }
+            case 24:
+              _context6.next = 8;
+              break;
+            case 26:
+              _context6.next = 31;
+              break;
+            case 28:
+              _context6.prev = 28;
+              _context6.t0 = _context6["catch"](6);
+              _iterator.e(_context6.t0);
+            case 31:
+              _context6.prev = 31;
+              _iterator.f();
+              return _context6.finish(31);
+            case 34:
               return _context6.abrupt("return", {
                 rawFallbackValue: rawFallbackValue,
                 fallbackValue: fallbackValue,
-                resolvedImportDeclaration: undefined,
-                resolvedLocalVarDeclaration: undefined
+                resolvedImportDeclaration: resolvedImportDeclaration,
+                resolvedLocalVarDeclaration: resolvedLocalVarDeclaration
               });
-            case 6:
+            case 35:
               expression = expressions[0];
               if (!(expression.type === 'Identifier')) {
-                _context6.next = 16;
+                _context6.next = 45;
                 break;
               }
-              _context6.next = 10;
+              _context6.next = 39;
               return this.processFallbackAsIdentifier(expression);
-            case 10:
-              result = _context6.sent;
-              exprValue = result.fallbackValue;
-              resolvedImportDeclaration = result.resolvedImportDeclaration;
-              resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
-              _context6.next = 22;
+            case 39:
+              _result2 = _context6.sent;
+              exprValue = _result2.fallbackValue;
+              resolvedImportDeclaration = _result2.resolvedImportDeclaration;
+              resolvedLocalVarDeclaration = _result2.resolvedLocalVarDeclaration;
+              _context6.next = 51;
               break;
-            case 16:
+            case 45:
               if (!(expression.type === 'MemberExpression')) {
-                _context6.next = 22;
+                _context6.next = 51;
                 break;
               }
-              _context6.next = 19;
+              _context6.next = 48;
               return this.processFallbackAsMemberExpression(expression);
-            case 19:
-              _result = _context6.sent;
-              exprValue = _result.fallbackValue;
-              resolvedImportDeclaration = _result.resolvedImportDeclaration;
-            case 22:
+            case 48:
+              _result3 = _context6.sent;
+              exprValue = _result3.fallbackValue;
+              resolvedImportDeclaration = _result3.resolvedImportDeclaration;
+            case 51:
               if (exprValue !== undefined) {
                 rawFallbackValue = "".concat(quasis[0].value.raw, "${").concat(exprValue, "}").concat(quasis[1].value.raw);
                 fallbackValue = "".concat(quasis[0].value.cooked).concat(exprValue).concat(quasis[1].value.cooked);
@@ -451,11 +559,11 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 resolvedImportDeclaration: resolvedImportDeclaration,
                 resolvedLocalVarDeclaration: resolvedLocalVarDeclaration
               });
-            case 24:
+            case 53:
             case "end":
               return _context6.stop();
           }
-        }, _callee6, this);
+        }, _callee6, this, [[6, 28, 31, 34]]);
       }));
       function processFallbackAsTemplateLiteral(_x6) {
         return _processFallbackAsTemplateLiteral.apply(this, arguments);
@@ -479,19 +587,19 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
     key: "tryResolveLocalPath",
     value: function () {
       var _tryResolveLocalPath = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(currentDir, importPath) {
-        var _iterator, _step, ext, potentialPath;
+        var _iterator2, _step2, ext, potentialPath;
         return _regenerator.default.wrap(function _callee7$(_context7) {
           while (1) switch (_context7.prev = _context7.next) {
             case 0:
-              _iterator = _createForOfIteratorHelper(this.possibleExtensions);
+              _iterator2 = _createForOfIteratorHelper(this.possibleExtensions);
               _context7.prev = 1;
-              _iterator.s();
+              _iterator2.s();
             case 3:
-              if ((_step = _iterator.n()).done) {
+              if ((_step2 = _iterator2.n()).done) {
                 _context7.next = 17;
                 break;
               }
-              ext = _step.value;
+              ext = _step2.value;
               potentialPath = _path.default.resolve(currentDir, "".concat(importPath).concat(ext));
               _context7.prev = 6;
               _context7.next = 9;
@@ -511,10 +619,10 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
             case 19:
               _context7.prev = 19;
               _context7.t1 = _context7["catch"](1);
-              _iterator.e(_context7.t1);
+              _iterator2.e(_context7.t1);
             case 22:
               _context7.prev = 22;
-              _iterator.f();
+              _iterator2.f();
               return _context7.finish(22);
             case 25:
               return _context7.abrupt("return", null);

package/dist/es2019/main.js

@@ -88,12 +88,18 @@ const runTransform = async (filePaths, transform, flags) => {
   }
   logger.log(chalk.green(`Transforming files matching these extensions '${chalk.bold(flags.extensions)}'...`));
   const transformPath = getTransformPath(transform);
+
+  // Split the ignorePattern by '|' and add each as a separate --ignore-pattern
+  const ignorePatterns = flags.ignorePattern.split('|').filter(Boolean);
+  const ignoreArgs = ignorePatterns.map(pattern => `--ignore-pattern=${pattern}`);
   const args = Object.keys(flags).reduce((acc, key) => {
     if (!['transform', 'parser', 'extensions', 'ignorePattern', 'logger', 'packages', 'sinceRef', 'preset', 'failOnError'].includes(key)) {
       acc.unshift(`--${key}=${flags[key]}`);
     }
     return acc;
-  }, [`--transform=${transformPath}`, `--ignore-pattern=${flags.ignorePattern}`, `--parser=${flags.parser}`, `--extensions=${flags.extensions}`,
+  }, [`--transform=${transformPath}`, ...ignoreArgs,
+  // Spread the ignoreArgs array here
+  `--parser=${flags.parser}`, `--extensions=${flags.extensions}`,
   // Limit CPUs to 8 to prevent issues when running on CI with a large amount of cpus
   '--cpus=8', ...codemodDirs]);
   if (flags.failOnError) {

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

@@ -7,6 +7,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';
@@ -59,6 +60,9 @@ export default async function transformer(fileInfo, {
   });
   const results = await Promise.all(transformPromises);
   const unusedVars = [];
+  if (options.reportFolder) {
+    await writeReports(details, options.reportFolder);
+  }
   if (results.some(result => result.fallbackRemoved)) {
     const allImports = results.flatMap(result => {
       var _result$resolvedImpor;
@@ -75,20 +79,22 @@ export default async function transformer(fileInfo, {
       }
       removeUnusedImports(allImports, j);
     }
-  }
-  removeUnusedVariables(unusedVars, j);
-  if (options.reportFolder) {
-    await writeReports(details, options.reportFolder);
-  }
-  if (options.dry) {
-    if (options.verbose) {
-      console.log(chalk.cyan(`${fileInfo.path}: dry run mode active. Source was not modified.`));
+    if (unusedVars.length) {
+      removeUnusedVariables(unusedVars, j);
+    }
+    if (options.dry) {
+      if (options.verbose) {
+        console.log(chalk.cyan(`${fileInfo.path}: dry run mode active. Source was not modified.`));
+      }
+      // Return the unmodified source if dryRun is true
+      return fileInfo.source;
+    } else {
+      // Return the transformed source
+      return source.toSource();
     }
+  } else {
     // Return the unmodified source if dryRun is true
     return fileInfo.source;
-  } else {
-    // Return the transformed source
-    return source.toSource();
   }
 }
 export const parser = 'tsx';
@@ -104,7 +110,7 @@ export async function beforeAll(options) {
 
 /**
  * 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.
  */
 export async function afterAll(options) {
   if (options.reportFolder) {
@@ -115,16 +121,115 @@ export async function afterAll(options) {
       const filesTxtPath = path.join(options.reportFolder, 'files.txt');
       const fileContent = await fs.readFile(filesTxtPath, 'utf-8');
       if (fileContent.length > 0) {
-        console.log(`Running prettier on files: ${chalk.magenta(fileContent)}`);
-        await execAsync(`yarn prettier --write ${fileContent}`);
-        console.log(chalk.green(`Prettier was run successfully`));
+        const filePaths = fileContent.split(/\r?\n/).filter(Boolean);
+
+        // Get the first file path and strip any quotes
+        const firstFilePath = filePaths[0].replace(/^['"]|['"]$/g, '');
+
+        // Determine the root directory using findRoot
+        const rootDir = await findRoot(path.dirname(firstFilePath));
+        console.log('Root directory:', rootDir);
+        await gitStage(filePaths, rootDir);
+        await runEslint(filePaths, rootDir);
+        await runPrettier(filePaths, rootDir);
       }
     } catch (error) {
       if (error instanceof Error) {
-        console.error(chalk.red(`Unexpected error running Prettier: ${error.message}`));
+        console.error(chalk.red(`Unexpected error: ${error.message}`));
       } else {
-        console.error(chalk.red('An unknown error occurred while running Prettier.'));
+        console.error(chalk.red('An unknown error occurred.'));
+      }
+    }
+  }
+}
+async function gitStage(filePaths, cwd) {
+  const gitAddCommand = `git add ${filePaths.join(' ')}`;
+  console.log(`Executing command: ${gitAddCommand}`);
+  const {
+    stdout: gitAddStdout,
+    stderr: gitAddStderr
+  } = await execAsync(gitAddCommand, {
+    cwd
+  });
+  if (gitAddStdout) {
+    console.log(chalk.blue(`Git add output:\n${gitAddStdout}`));
+  }
+  if (gitAddStderr) {
+    console.error(chalk.yellow(`Git add errors:\n${gitAddStderr}`));
+  }
+  console.log(chalk.green(`All changes have been staged.`));
+}
+async function runPrettier(filePaths, cwd) {
+  const prettierCommand = `yarn prettier --write ${filePaths.join(' ')}`;
+  console.log(`Executing command: ${prettierCommand}`);
+  const {
+    stdout: prettierStdout,
+    stderr: prettierStderr
+  } = await execAsync(prettierCommand, {
+    cwd
+  });
+  if (prettierStdout) {
+    console.log(chalk.blue(`Prettier output:\n${prettierStdout}`));
+  }
+  if (prettierStderr) {
+    console.error(chalk.yellow(`Prettier errors:\n${prettierStderr}`));
+  }
+  console.log(chalk.green(`Prettier was run successfully`));
+}
+async function runEslint(filePaths, cwd) {
+  const fileChunks = chunkArray(filePaths, 20);
+  const totalChunks = fileChunks.length;
+  for (const [chunkIndex, fileChunk] of fileChunks.entries()) {
+    const eslintCommand = `yarn eslint ${fileChunk.join(' ')} --report-unused-disable-directives --fix`;
+    console.log(`Executing command for chunk ${chunkIndex + 1} of ${totalChunks}: ${eslintCommand}`);
+    try {
+      const result = await execAsync(eslintCommand, {
+        cwd
+      });
+      const {
+        stdout,
+        stderr
+      } = result;
+      if (stdout) {
+        console.log(chalk.blue(`ESLint output for chunk ${chunkIndex + 1} of ${totalChunks}:\n${stdout}`));
+      }
+      if (stderr) {
+        console.error(chalk.yellow(`ESLint errors for chunk ${chunkIndex + 1} of ${totalChunks}:\n${stderr}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error running ESLint on chunk ${chunkIndex + 1} of ${totalChunks}: ${error}`));
+
+      // Retry each file individually
+      console.log(chalk.yellow(`Retrying each file in chunk ${chunkIndex + 1} of ${totalChunks} individually...`));
+
+      // Chunk the files into smaller groups of 5 for parallel retry
+      const smallerChunks = chunkArray(fileChunk, 5);
+      const totalSmallerChunks = smallerChunks.length;
+      for (const [smallChunkIndex, smallerChunk] of smallerChunks.entries()) {
+        await Promise.all(smallerChunk.map(async file => {
+          try {
+            const individualEslintCommand = `yarn eslint ${file} --report-unused-disable-directives --fix`;
+            console.log(`Executing command for file in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}: ${individualEslintCommand}`);
+            const result = await execAsync(individualEslintCommand, {
+              cwd
+            });
+            const {
+              stdout,
+              stderr
+            } = result;
+            if (stdout) {
+              console.log(chalk.blue(`ESLint output for file ${file} in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}:\n${stdout}`));
+            }
+            if (stderr) {
+              console.error(chalk.yellow(`ESLint errors for file ${file} in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}:\n${stderr}`));
+            }
+          } catch (fileError) {
+            console.error(chalk.red(`Error running ESLint on file ${file} in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}: ${fileError}`));
+          }
+        }));
       }
     }
+    console.log(chalk.green(`Finished running ESLint for chunk ${chunkIndex + 1} of ${totalChunks}.`));
   }
+  console.log(chalk.green(`ESLint was run on all files successfully`));
 }

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

@@ -0,0 +1,8 @@
+// Utility function to split an array into chunks
+export const chunkArray = (array, chunkSize) => {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};

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

@@ -2,9 +2,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
-const ACCEPTABLE_COLOR_DIFFERENCE = 0;
+const ACCEPTABLE_COLOR_DIFFERENCE = 15;
 const ACCEPTABLE_SPACE_DIFFERENCE = 0;
 const ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
+const ACCEPTABLE_BORDER_DIFFERENCE = 0;
 export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
   let tokenLogValue;
   let fallbackLogValue;
@@ -28,13 +29,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')) {
     const tokenValueInPx = tokenValue ? convertToPx(tokenValue) : undefined;
     const fallbackValueInPx = fallbackValue ? convertToPx(fallbackValue) : undefined;
     if (tokenValueInPx !== undefined && fallbackValueInPx !== undefined) {
       const 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/es2019/presets/remove-token-fallbacks/utils/remove-unused-imports.js

@@ -35,13 +35,13 @@ export function removeUnusedImports(importDeclarations, j) {
     return j(importDeclaration).find(j.ImportSpecifier).filter(s => removeIfUnused(s, importDeclaration)).size() > 0;
   };
   const processImportDeclaration = importDeclaration => {
-    var _importDeclaration$va, _importDeclaration$va2;
-    if (((_importDeclaration$va = importDeclaration.value.specifiers) === null || _importDeclaration$va === void 0 ? void 0 : _importDeclaration$va.length) === 0) {
+    var _importDeclaration$va, _importDeclaration$va2, _importDeclaration$va3, _importDeclaration$va4;
+    if (((_importDeclaration$va = importDeclaration.value) === null || _importDeclaration$va === void 0 ? void 0 : (_importDeclaration$va2 = _importDeclaration$va.specifiers) === null || _importDeclaration$va2 === void 0 ? void 0 : _importDeclaration$va2.length) === 0) {
       return false;
     }
     const hadUnusedDefaultImport = removeUnusedDefaultImport(importDeclaration);
     const hadUnusedNonDefaultImports = removeUnusedNonDefaultImports(importDeclaration);
-    if (((_importDeclaration$va2 = importDeclaration.value.specifiers) === null || _importDeclaration$va2 === void 0 ? void 0 : _importDeclaration$va2.length) === 0) {
+    if (((_importDeclaration$va3 = importDeclaration.value) === null || _importDeclaration$va3 === void 0 ? void 0 : (_importDeclaration$va4 = _importDeclaration$va3.specifiers) === null || _importDeclaration$va4 === void 0 ? void 0 : _importDeclaration$va4.length) === 0) {
       j(importDeclaration).remove();
       return true;
     }

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

@@ -25,6 +25,10 @@ function escapeCsvValue(value) {
 }
 export async function clearFolder(reportFolder) {
   console.log('Clearing report folder:', reportFolder);
+  // Create the folder if it doesn't exist
+  await fs.mkdir(reportFolder, {
+    recursive: true
+  });
   const filesToDelete = await fs.readdir(reportFolder);
   for (const file of filesToDelete) {
     const filePath = path.join(reportFolder, file);
@@ -33,7 +37,8 @@ export async function clearFolder(reportFolder) {
 }
 async function saveFilePaths(reportFolder, files) {
   const filesTxtPath = path.join(reportFolder, 'files.txt');
-  await fs.writeFile(filesTxtPath, Array.from(files).map(filePath => `"${filePath}"`).join(' '), 'utf-8');
+  const sortedFiles = Array.from(files).sort(); // Sort the file paths alphabetically
+  await fs.writeFile(filesTxtPath, sortedFiles.map(filePath => `"${filePath}"`).join('\n'), 'utf-8');
 }
 export async function combineReports(reportFolder) {
   console.log('Combining reports in folder:', reportFolder);