@atlaskit/codemod-cli 0.27.4 → 0.28.1

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

@@ -8,11 +8,17 @@ exports.normalizeValues = normalizeValues;
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _chalk = _interopRequireDefault(require("chalk"));
 var _colorUtils = require("./color-utils");
-// so far allowing to remove only exact matches in values. Can be increased to auto-remove fallbacks with similar values
-var ACCEPTABLE_COLOR_DIFFERENCE = 0;
-var ACCEPTABLE_SPACE_DIFFERENCE = 0;
-var ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
-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;
+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;
@@ -33,15 +39,15 @@ function normalizeValues(tokenKey, tokenValue, fallbackValue) {
     }
     if (normalizedTokenValue && normalizedFallbackValue) {
       difference = (0, _colorUtils.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;
@@ -55,7 +61,7 @@ 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/cjs/presets/remove-token-fallbacks/utils/remove-unused-imports.js

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

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

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

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TokenProcessor = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
@@ -89,12 +90,43 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
     value: function logError(message) {
       this.log(_chalk.default.red(message));
     }
+
+    /**
+     * Checks if a token should be exempted from automatic fallback removal
+     * @param tokenKey The token key to check
+     * @returns An object containing whether the token should be exempted and related information
+     */
+  }, {
+    key: "checkTokenExemption",
+    value: function checkTokenExemption(tokenKey) {
+      // Create exemption list from user-provided skipTokens, and always include 'border'
+      var userExemptions = this.options.skipTokens ? this.options.skipTokens.split(',').map(function (item) {
+        return item.trim();
+      }) : [];
+
+      // Always include 'border' in the exemption list
+      var exemptionList = (0, _toConsumableArray2.default)(userExemptions);
+      if (!exemptionList.includes('border')) {
+        exemptionList.push('border');
+      }
+      var isExemptedToken = exemptionList.some(function (prefix) {
+        return tokenKey.startsWith(prefix);
+      });
+      var exemptedPrefix = isExemptedToken ? exemptionList.find(function (prefix) {
+        return tokenKey.startsWith(prefix);
+      }) || null : null;
+      return {
+        shouldBeExempted: isExemptedToken,
+        exemptedPrefix: exemptedPrefix,
+        exemptionList: exemptionList
+      };
+    }
   }, {
     key: "processSingleToken",
     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, tokenValue, _yield$this$getFallba, rawFallbackValue, fallbackValue, resolvedImportDeclaration, resolvedLocalVarDeclaration, _normalizeValues, difference, isAcceptableDifference, tokenLogValue, fallbackLogValue, normalizedTokenValue, normalizedFallbackValue, areEqual, logData, fallbackRemoved, importDeclaration, localVarDeclaration, _this$checkTokenExemp, shouldBeExempted, exemptedPrefix, shouldModifyToken, message;
         return _regenerator.default.wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
@@ -124,33 +156,17 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 resolvedLocalVarDeclaration: undefined
               });
             case 8:
-              isSkipped = tokenKey.startsWith('elevation.shadow') || tokenKey.startsWith('font.body') || tokenKey.startsWith('font.heading');
-              tokenValue = isSkipped ? '' : this.tokenMap[tokenKey];
+              tokenValue = this.tokenMap[tokenKey];
               this.logVerbose("Token value from tokenMap: ".concat(_chalk.default.magenta(tokenValue), " for key: ").concat(_chalk.default.yellow(tokenKey)));
-              if (!isSkipped) {
-                _context2.next = 15;
-                break;
-              }
-              _context2.t0 = {
-                rawFallbackValue: 'N/A',
-                fallbackValue: undefined,
-                resolvedImportDeclaration: undefined,
-                resolvedLocalVarDeclaration: undefined
-              };
-              _context2.next = 18;
-              break;
-            case 15:
-              _context2.next = 17;
+              _context2.next = 12;
               return this.getFallbackValue(args[1]);
-            case 17:
-              _context2.t0 = _context2.sent;
-            case 18:
-              _ref = _context2.t0;
-              rawFallbackValue = _ref.rawFallbackValue;
-              fallbackValue = _ref.fallbackValue;
-              resolvedImportDeclaration = _ref.resolvedImportDeclaration;
-              resolvedLocalVarDeclaration = _ref.resolvedLocalVarDeclaration;
-              _normalizeValues = (0, _normalizeValues2.normalizeValues)(tokenKey, tokenValue, fallbackValue), difference = _normalizeValues.difference, isAcceptableDifference = _normalizeValues.isAcceptableDifference, tokenLogValue = _normalizeValues.tokenLogValue, fallbackLogValue = _normalizeValues.fallbackLogValue, normalizedTokenValue = _normalizeValues.normalizedTokenValue, normalizedFallbackValue = _normalizeValues.normalizedFallbackValue;
+            case 12:
+              _yield$this$getFallba = _context2.sent;
+              rawFallbackValue = _yield$this$getFallba.rawFallbackValue;
+              fallbackValue = _yield$this$getFallba.fallbackValue;
+              resolvedImportDeclaration = _yield$this$getFallba.resolvedImportDeclaration;
+              resolvedLocalVarDeclaration = _yield$this$getFallba.resolvedLocalVarDeclaration;
+              _normalizeValues = (0, _normalizeValues2.normalizeValues)(tokenKey, tokenValue, fallbackValue, this.options), difference = _normalizeValues.difference, isAcceptableDifference = _normalizeValues.isAcceptableDifference, tokenLogValue = _normalizeValues.tokenLogValue, fallbackLogValue = _normalizeValues.fallbackLogValue, normalizedTokenValue = _normalizeValues.normalizedTokenValue, normalizedFallbackValue = _normalizeValues.normalizedFallbackValue;
               areEqual = normalizedTokenValue === normalizedFallbackValue;
               logData = {
                 teamInfo: this.teamInfo,
@@ -163,7 +179,16 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 difference: difference
               };
               fallbackRemoved = false;
-              if (areEqual || isAcceptableDifference || this.options.forceUpdate) {
+              // Check if token should be exempted
+              _this$checkTokenExemp = this.checkTokenExemption(tokenKey), shouldBeExempted = _this$checkTokenExemp.shouldBeExempted, exemptedPrefix = _this$checkTokenExemp.exemptedPrefix; // Determine if we should modify this token based on the exemption status and settings
+              shouldModifyToken =
+              // Always modify if not exempted and values match
+              areEqual && !shouldBeExempted ||
+              // Or if values don't exactly match but are acceptable to modify and not exempted
+              (isAcceptableDifference || this.options.forceUpdate) && !shouldBeExempted ||
+              // Or if exempted but values match exactly and we're not preserving skipped fallbacks
+              areEqual && shouldBeExempted && !this.options.preserveSkippedFallbacks;
+              if (shouldModifyToken) {
                 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 +196,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 = shouldBeExempted ? this.options.preserveSkippedFallbacks && areEqual ? "Preserving fallback for exempted token '".concat(tokenKey, "' (matches exemption '").concat(exemptedPrefix, "')") : "Skip modifying exempted token '".concat(tokenKey, "' (matches exemption '").concat(exemptedPrefix, "')") : 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 +210,7 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
                 resolvedImportDeclaration: importDeclaration,
                 resolvedLocalVarDeclaration: localVarDeclaration
               });
-            case 30:
+            case 26:
             case "end":
               return _context2.stop();
           }
@@ -328,10 +353,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 +413,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 +423,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 +468,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 +581,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 +609,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 +641,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);
@@ -603,7 +733,7 @@ var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
           }
         }, _callee8, this);
       }));
-      function resolveValueFromImport(_x9, _x10, _x11, _x12) {
+      function resolveValueFromImport(_x9, _x0, _x1, _x10) {
         return _resolveValueFromImport.apply(this, arguments);
       }
       return resolveValueFromImport;

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) {