@atlaskit/codemod-cli 0.27.4 → 0.28.1

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';
@@ -30,6 +35,14 @@ var execAsync = promisify(exec);
  *   @param {boolean} [options.useLegacyColorTheme] - If true, uses the legacy theme for color token mapping.
  *   @param {string} [options.reportFolder] - Directory path to output transformation reports. Reports will be generated only if this option is provided.
  *   @param {boolean} [options.dry] - If true, performs a dry run without modifying the files.
+ *   @param {string} [options.skipTokens] - A comma-separated list of token prefixes to exempt from automatic fallback removal. By default, 'border' tokens are always included in this list. Whether fallbacks for these tokens are removed when they exactly match depends on the preserveSkippedFallbacks option.
+ *   @param {boolean} [options.preserveSkippedFallbacks] - If true, fallbacks for skipped tokens will never be removed, even if they exactly match the token value. If false (default), fallbacks for skipped tokens will be removed if they exactly match.
+ *   @param {boolean} [options.skipEslint] - If true, skips running ESLint on modified files after transformation.
+ *   @param {boolean} [options.skipPrettier] - If true, skips running Prettier on modified files after transformation.
+ *   @param {number} [options.colorDifferenceThreshold] - The maximum allowed difference for color tokens to be considered acceptable for removal. Default is 15.
+ *   @param {number} [options.spaceDifferenceThreshold] - The maximum allowed percentage difference for space tokens to be considered acceptable for removal. Default is 0.
+ *   @param {number} [options.numericDifferenceThreshold] - The maximum allowed percentage difference for numeric tokens to be considered acceptable for removal. Default is 0.
+ *   @param {number} [options.borderDifferenceThreshold] - The maximum allowed percentage difference for border tokens to be considered acceptable for removal. Default is 0.
  *
  * @returns {Promise<string>} A promise that resolves to the transformed source code as a string.
  */
@@ -61,6 +74,32 @@ function _transformer() {
           };
           if (options.verbose) {
             console.log(chalk.yellow("Using ".concat(options.useLegacyColorTheme ? 'legacy light' : 'light', " theme.")));
+            if (options.skipTokens) {
+              console.log(chalk.yellow("Auto fallback exemptions active for: ".concat(options.skipTokens)));
+            }
+            if (options.preserveSkippedFallbacks) {
+              console.log(chalk.yellow("Preserving all fallbacks for skipped tokens, even if they match exactly."));
+            }
+            if (options.skipEslint) {
+              console.log(chalk.yellow("Skipping ESLint post-processing."));
+            }
+            if (options.skipPrettier) {
+              console.log(chalk.yellow("Skipping Prettier post-processing."));
+            }
+
+            // Log threshold values if they are set
+            if (options.colorDifferenceThreshold !== undefined) {
+              console.log(chalk.yellow("Color difference threshold set to: ".concat(options.colorDifferenceThreshold)));
+            }
+            if (options.spaceDifferenceThreshold !== undefined) {
+              console.log(chalk.yellow("Space difference threshold set to: ".concat(options.spaceDifferenceThreshold, "%")));
+            }
+            if (options.numericDifferenceThreshold !== undefined) {
+              console.log(chalk.yellow("Numeric difference threshold set to: ".concat(options.numericDifferenceThreshold, "%")));
+            }
+            if (options.borderDifferenceThreshold !== undefined) {
+              console.log(chalk.yellow("Border difference threshold set to: ".concat(options.borderDifferenceThreshold, "%")));
+            }
           }
           tokenMap = getTokenMap((_options$useLegacyCol = options.useLegacyColorTheme) !== null && _options$useLegacyCol !== void 0 ? _options$useLegacyCol : false);
           _context.next = 12;
@@ -81,35 +120,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 +160,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 +186,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 +212,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 +224,7 @@ function _afterAll() {
           return combineReports(options.reportFolder);
         case 3:
           if (!(options.reportFolder && !options.dry)) {
-            _context3.next = 19;
+            _context3.next = 35;
             break;
           }
           _context3.prev = 4;
@@ -186,30 +234,291 @@ function _afterAll() {
         case 8:
           fileContent = _context3.sent;
           if (!(fileContent.length > 0)) {
-            _context3.next = 14;
+            _context3.next = 30;
             break;
           }
-          console.log("Running prettier on files: ".concat(chalk.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:
+          if (options.skipEslint) {
+            _context3.next = 23;
+            break;
+          }
+          _context3.next = 21;
+          return runEslint(filePaths, rootDir);
+        case 21:
+          _context3.next = 24;
           break;
-        case 16:
-          _context3.prev = 16;
+        case 23:
+          if (options.verbose) {
+            console.log(chalk.blue('Skipping ESLint post-processing as requested.'));
+          }
+        case 24:
+          if (options.skipPrettier) {
+            _context3.next = 29;
+            break;
+          }
+          _context3.next = 27;
+          return runPrettier(filePaths, rootDir);
+        case 27:
+          _context3.next = 30;
+          break;
+        case 29:
+          if (options.verbose) {
+            console.log(chalk.blue('Skipping Prettier post-processing as requested.'));
+          }
+        case 30:
+          _context3.next = 35;
+          break;
+        case 32:
+          _context3.prev = 32;
           _context3.t0 = _context3["catch"](4);
           if (_context3.t0 instanceof Error) {
-            console.error(chalk.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 35:
         case "end":
           return _context3.stop();
       }
-    }, _callee3, null, [[4, 16]]);
+    }, _callee3, null, [[4, 32]]);
   }));
   return _afterAll.apply(this, arguments);
+}
+function gitStage(_x6, _x7) {
+  return _gitStage.apply(this, arguments);
+}
+function _gitStage() {
+  _gitStage = _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(_x0, _x1) {
+  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 (_x10) {
+                              return _ref2.apply(this, arguments);
+                            };
+                          }()));
+                        case 3:
+                        case "end":
+                          return _context7.stop();
+                      }
+                    }, _loop2);
+                  });
+                  _iterator2.s();
+                case 22:
+                  if ((_step2 = _iterator2.n()).done) {
+                    _context8.next = 26;
+                    break;
+                  }
+                  return _context8.delegateYield(_loop2(), "t1", 24);
+                case 24:
+                  _context8.next = 22;
+                  break;
+                case 26:
+                  _context8.next = 31;
+                  break;
+                case 28:
+                  _context8.prev = 28;
+                  _context8.t2 = _context8["catch"](19);
+                  _iterator2.e(_context8.t2);
+                case 31:
+                  _context8.prev = 31;
+                  _iterator2.f();
+                  return _context8.finish(31);
+                case 34:
+                  console.log(chalk.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

@@ -2,11 +2,17 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 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_SPACE_DIFFERENCE = 0;
-var ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
-export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
+// Default threshold values
+var DEFAULT_COLOR_DIFFERENCE = 15;
+var DEFAULT_SPACE_DIFFERENCE = 0;
+var DEFAULT_NUMERIC_DIFFERENCE = 0;
+var DEFAULT_BORDER_DIFFERENCE = 0;
+export function normalizeValues(tokenKey, tokenValue, fallbackValue, options) {
+  // Use options thresholds or defaults
+  var colorDifference = (options === null || options === void 0 ? void 0 : options.colorDifferenceThreshold) !== undefined ? options.colorDifferenceThreshold : DEFAULT_COLOR_DIFFERENCE;
+  var spaceDifference = (options === null || options === void 0 ? void 0 : options.spaceDifferenceThreshold) !== undefined ? options.spaceDifferenceThreshold : DEFAULT_SPACE_DIFFERENCE;
+  var numericDifference = (options === null || options === void 0 ? void 0 : options.numericDifferenceThreshold) !== undefined ? options.numericDifferenceThreshold : DEFAULT_NUMERIC_DIFFERENCE;
+  var borderDifference = (options === null || options === void 0 ? void 0 : options.borderDifferenceThreshold) !== undefined ? options.borderDifferenceThreshold : DEFAULT_BORDER_DIFFERENCE;
   var tokenLogValue;
   var fallbackLogValue;
   var normalizedTokenValue = tokenValue;
@@ -27,15 +33,15 @@ export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
     }
     if (normalizedTokenValue && normalizedFallbackValue) {
       difference = compareHex(normalizedTokenValue, normalizedFallbackValue);
-      isAcceptableDifference = difference <= ACCEPTABLE_COLOR_DIFFERENCE;
+      isAcceptableDifference = difference <= colorDifference;
     }
-  } 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') ? spaceDifference : borderDifference);
     }
     // Log the normalized values
     normalizedTokenValue = tokenValue;
@@ -49,7 +55,7 @@ export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
     if (!isNaN(tokenValueNumber) && !isNaN(fallbackValueNumber)) {
       var _maxVal = Math.max(tokenValueNumber, fallbackValueNumber);
       difference = Math.abs(tokenValueNumber - fallbackValueNumber) / _maxVal * 100;
-      isAcceptableDifference = difference <= ACCEPTABLE_NUMERIC_DIFFERENCE;
+      isAcceptableDifference = difference <= numericDifference;
     }
     // Log the normalized values
     normalizedTokenValue = tokenValue;

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

@@ -40,12 +40,12 @@ export 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/esm/presets/remove-token-fallbacks/utils/reporter.js

@@ -74,41 +74,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 fs.readdir(reportFolder);
+          return fs.mkdir(reportFolder, {
+            recursive: true
+          });
         case 3:
+          _context3.next = 5;
+          return fs.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.join(reportFolder, file);
-          _context3.next = 12;
+          _context3.next = 14;
           return fs.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);
 }
@@ -117,16 +123,17 @@ function saveFilePaths(_x5, _x6) {
 }
 function _saveFilePaths() {
   _saveFilePaths = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(reportFolder, files) {
-    var filesTxtPath;
+    var filesTxtPath, sortedFiles;
     return _regeneratorRuntime.wrap(function _callee4$(_context4) {
       while (1) switch (_context4.prev = _context4.next) {
         case 0:
           filesTxtPath = path.join(reportFolder, 'files.txt');
-          _context4.next = 3;
-          return fs.writeFile(filesTxtPath, Array.from(files).map(function (filePath) {
+          sortedFiles = Array.from(files).sort(); // Sort the file paths alphabetically
+          _context4.next = 4;
+          return fs.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();
       }