@atlaskit/codemod-cli 0.27.2 → 0.27.4

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

@@ -0,0 +1,625 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+var _excluded = ["shouldLog"];
+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 fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { normalizeValues } from './normalize-values';
+import { addOrUpdateEslintIgnoreComment } from './update-comments';
+export var TokenProcessor = /*#__PURE__*/function () {
+  function TokenProcessor(j, options, fileInfo, source, rootDir, details, tokenMap, teamInfo) {
+    _classCallCheck(this, TokenProcessor);
+    _defineProperty(this, "logMessages", []);
+    _defineProperty(this, "possibleExtensions", ['.ts', '.tsx', '.js', '.jsx']);
+    this.j = j;
+    this.options = options;
+    this.fileInfo = fileInfo;
+    this.source = source;
+    this.rootDir = rootDir;
+    this.details = details;
+    this.tokenMap = tokenMap;
+    this.teamInfo = teamInfo;
+  }
+  return _createClass(TokenProcessor, [{
+    key: "processAndLogSingleToken",
+    value: function () {
+      var _processAndLogSingleToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(callPath) {
+        var _callPath$node$loc;
+        var line, _yield$this$processSi, shouldLog, rest, coloredPath, coloredLine;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              line = (_callPath$node$loc = callPath.node.loc) === null || _callPath$node$loc === void 0 ? void 0 : _callPath$node$loc.start.line;
+              _context.next = 3;
+              return this.processSingleToken(callPath);
+            case 3:
+              _yield$this$processSi = _context.sent;
+              shouldLog = _yield$this$processSi.shouldLog;
+              rest = _objectWithoutProperties(_yield$this$processSi, _excluded);
+              if (!(this.options.silent || !shouldLog)) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", rest);
+            case 8:
+              coloredPath = chalk.blue(this.fileInfo.path);
+              coloredLine = line ? ": ".concat(chalk.green(line)) : '';
+              console.log("".concat(coloredPath).concat(coloredLine, ": ").concat(this.logMessages.join(' | '), "\n----------------------------------------"));
+              return _context.abrupt("return", rest);
+            case 12:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function processAndLogSingleToken(_x) {
+        return _processAndLogSingleToken.apply(this, arguments);
+      }
+      return processAndLogSingleToken;
+    }()
+  }, {
+    key: "logVerbose",
+    value: function logVerbose(message) {
+      if (this.options.verbose) {
+        this.log(message);
+      }
+    }
+  }, {
+    key: "log",
+    value: function log(message) {
+      this.logMessages.push(message);
+    }
+  }, {
+    key: "logError",
+    value: function logError(message) {
+      this.log(chalk.red(message));
+    }
+  }, {
+    key: "processSingleToken",
+    value: function () {
+      var _processSingleToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.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;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              args = callPath.node.arguments;
+              line = (_callPath$node$loc2 = callPath.node.loc) === null || _callPath$node$loc2 === void 0 ? void 0 : _callPath$node$loc2.start.line;
+              if (!(args.length < 2)) {
+                _context2.next = 5;
+                break;
+              }
+              this.logVerbose(chalk.yellow('Skipped token call without fallback'));
+              return _context2.abrupt("return", {
+                shouldLog: false,
+                fallbackRemoved: false,
+                resolvedImportDeclaration: undefined,
+                resolvedLocalVarDeclaration: undefined
+              });
+            case 5:
+              tokenKey = this.getTokenKey(args[0]);
+              if (tokenKey) {
+                _context2.next = 8;
+                break;
+              }
+              return _context2.abrupt("return", {
+                shouldLog: true,
+                fallbackRemoved: false,
+                resolvedImportDeclaration: undefined,
+                resolvedLocalVarDeclaration: undefined
+              });
+            case 8:
+              isSkipped = 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.magenta(tokenValue), " for key: ").concat(chalk.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;
+              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 = normalizeValues(tokenKey, tokenValue, fallbackValue), 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,
+                filePath: this.fileInfo.path,
+                lineNumber: line || -1,
+                tokenKey: tokenKey,
+                rawFallbackValue: rawFallbackValue,
+                resolvedTokenValue: tokenValue,
+                resolvedFallbackValue: fallbackValue !== null && fallbackValue !== void 0 ? fallbackValue : '',
+                difference: difference
+              };
+              fallbackRemoved = false;
+              if (areEqual || isAcceptableDifference || this.options.forceUpdate) {
+                this.log(chalk.green(areEqual ? 'Token value and fallback value are equal, removing fallback' : 'Token value and fallback value are within acceptable difference threshold, removing fallback'));
+                args.pop();
+                this.details.replaced.push(logData);
+                fallbackRemoved = true;
+                importDeclaration = resolvedImportDeclaration;
+                localVarDeclaration = resolvedLocalVarDeclaration;
+              } else {
+                message = normalizedFallbackValue === undefined ? "Fallback value could not be resolved" : "Values mismatched significantly";
+                this.logError(message);
+                if (this.options.addEslintComments) {
+                  addOrUpdateEslintIgnoreComment(this.j, tokenValue, fallbackValue, callPath);
+                }
+                this.details.notReplaced.push(logData);
+              }
+              this.log("Token: ".concat(chalk.yellow(tokenKey), ", Raw fallback: ").concat(chalk.yellow(rawFallbackValue), ", Resolved token value: ").concat(tokenLogValue, ", Resolved fallback value: ").concat(fallbackLogValue));
+              return _context2.abrupt("return", {
+                shouldLog: true,
+                fallbackRemoved: fallbackRemoved,
+                resolvedImportDeclaration: importDeclaration,
+                resolvedLocalVarDeclaration: localVarDeclaration
+              });
+            case 30:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function processSingleToken(_x2) {
+        return _processSingleToken.apply(this, arguments);
+      }
+      return processSingleToken;
+    }()
+  }, {
+    key: "getTokenKey",
+    value: function getTokenKey(arg) {
+      if (arg.type === 'StringLiteral') {
+        var tokenKey = arg.value;
+        this.logVerbose("Determined token key as literal: ".concat(chalk.yellow(tokenKey)));
+        return tokenKey;
+      } else {
+        this.logError("The first argument of token function is not a string literal");
+        return undefined;
+      }
+    }
+  }, {
+    key: "getFallbackValue",
+    value: function () {
+      var _getFallbackValue = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(fallbackValueNode) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.t0 = fallbackValueNode.type;
+              _context3.next = _context3.t0 === 'StringLiteral' ? 3 : _context3.t0 === 'Identifier' ? 4 : _context3.t0 === 'MemberExpression' ? 5 : _context3.t0 === 'TemplateLiteral' ? 6 : 7;
+              break;
+            case 3:
+              return _context3.abrupt("return", this.processFallbackAsStringLiteral(fallbackValueNode));
+            case 4:
+              return _context3.abrupt("return", this.processFallbackAsIdentifier(fallbackValueNode));
+            case 5:
+              return _context3.abrupt("return", this.processFallbackAsMemberExpression(fallbackValueNode));
+            case 6:
+              return _context3.abrupt("return", this.processFallbackAsTemplateLiteral(fallbackValueNode));
+            case 7:
+              return _context3.abrupt("return", {
+                fallbackValue: undefined,
+                rawFallbackValue: '',
+                resolvedImportDeclaration: undefined,
+                resolvedLocalVarDeclaration: undefined
+              });
+            case 8:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function getFallbackValue(_x3) {
+        return _getFallbackValue.apply(this, arguments);
+      }
+      return getFallbackValue;
+    }()
+  }, {
+    key: "processFallbackAsStringLiteral",
+    value: function processFallbackAsStringLiteral(fallbackValueNode) {
+      var fallbackValue = fallbackValueNode.value;
+      this.logVerbose("Fallback value is a literal: ".concat(chalk.yellow(fallbackValue)));
+      return {
+        fallbackValue: fallbackValue,
+        rawFallbackValue: fallbackValue,
+        resolvedImportDeclaration: undefined,
+        resolvedLocalVarDeclaration: undefined
+      };
+    }
+  }, {
+    key: "processFallbackAsIdentifier",
+    value: function () {
+      var _processFallbackAsIdentifier = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(fallbackValueNode) {
+        var variableName, variableNameForLog, fallbackValue, localVarDeclaration, resolvedImportDeclaration, resolvedLocalVarDeclaration, init, importDeclaration, importSource;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              variableName = fallbackValueNode.name;
+              variableNameForLog = "".concat(chalk.yellow(variableName));
+              this.logVerbose("Fallback is an identifier: ".concat(chalk.yellow(variableName), ", attempting to resolve..."));
+
+              // Check for local variable declaration
+              localVarDeclaration = this.source.find(this.j.VariableDeclarator, {
+                id: {
+                  name: variableName
+                }
+              }).at(0);
+              if (!localVarDeclaration.size()) {
+                _context4.next = 9;
+                break;
+              }
+              init = localVarDeclaration.get().value.init;
+              if (init.type === 'Literal' || init.type === 'StringLiteral') {
+                fallbackValue = init.value;
+                resolvedLocalVarDeclaration = localVarDeclaration.paths()[0];
+                this.logVerbose("Resolved fallback value from local variable: ".concat(chalk.yellow(fallbackValue), " for identifier: ").concat(variableNameForLog));
+              }
+              _context4.next = 19;
+              break;
+            case 9:
+              // Check for named import
+              importDeclaration = this.source.find(this.j.ImportDeclaration).filter(this.createImportFilter(variableName)).at(0);
+              if (!importDeclaration.size()) {
+                _context4.next = 18;
+                break;
+              }
+              importSource = importDeclaration.get().value.source.value;
+              _context4.next = 14;
+              return this.resolveValueFromImport(this.rootDir, importSource, undefined, variableName);
+            case 14:
+              fallbackValue = _context4.sent;
+              if (fallbackValue !== undefined) {
+                this.logVerbose("Resolved fallback value from import: ".concat(chalk.yellow(fallbackValue), " for identifier: ").concat(variableNameForLog));
+                resolvedImportDeclaration = importDeclaration.paths()[0];
+              }
+              _context4.next = 19;
+              break;
+            case 18:
+              this.logVerbose(chalk.red("Could not resolve fallback value for identifier: ".concat(variableNameForLog, ": it's neither a local variable nor an import")));
+            case 19:
+              return _context4.abrupt("return", {
+                rawFallbackValue: variableName,
+                fallbackValue: fallbackValue,
+                resolvedImportDeclaration: resolvedImportDeclaration,
+                resolvedLocalVarDeclaration: resolvedLocalVarDeclaration
+              });
+            case 20:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function processFallbackAsIdentifier(_x4) {
+        return _processFallbackAsIdentifier.apply(this, arguments);
+      }
+      return processFallbackAsIdentifier;
+    }()
+  }, {
+    key: "processFallbackAsMemberExpression",
+    value: function () {
+      var _processFallbackAsMemberExpression = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5(fallbackValueNode) {
+        var objectName, propertyName, fallbackValue, rawFallbackValue, resolvedImportDeclaration, importDeclaration, importSource;
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              if (fallbackValueNode.object.type === 'Identifier') {
+                objectName = fallbackValueNode.object.name;
+              }
+              if (fallbackValueNode.property.type === 'Identifier') {
+                propertyName = fallbackValueNode.property.name;
+              } else if (fallbackValueNode.property.type === 'Literal' && typeof fallbackValueNode.property.value === 'string') {
+                propertyName = fallbackValueNode.property.value;
+              }
+              if (!(!objectName || !propertyName)) {
+                _context5.next = 5;
+                break;
+              }
+              this.logError("Could not determine object and property names from member expression: ".concat(chalk.yellow(fallbackValueNode)));
+              return _context5.abrupt("return", {
+                rawFallbackValue: '',
+                fallbackValue: fallbackValue,
+                resolvedImportDeclaration: undefined,
+                resolvedLocalVarDeclaration: undefined
+              });
+            case 5:
+              rawFallbackValue = "".concat(objectName, ".").concat(propertyName);
+              this.logVerbose("Fallback is a member expression: ".concat(chalk.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;
+                break;
+              }
+              importSource = importDeclaration.get().value.source.value;
+              _context5.next = 12;
+              return this.resolveValueFromImport(this.rootDir, importSource, objectName, propertyName);
+            case 12:
+              fallbackValue = _context5.sent;
+              if (fallbackValue !== undefined) {
+                resolvedImportDeclaration = importDeclaration.paths()[0];
+                this.logVerbose("Resolved fallback value from member expression: ".concat(chalk.yellow(fallbackValue)));
+              }
+              _context5.next = 17;
+              break;
+            case 16:
+              this.logError("Could not find import for member expression: ".concat(chalk.yellow(rawFallbackValue)));
+            case 17:
+              return _context5.abrupt("return", {
+                rawFallbackValue: rawFallbackValue,
+                fallbackValue: fallbackValue,
+                resolvedImportDeclaration: resolvedImportDeclaration,
+                resolvedLocalVarDeclaration: undefined
+              });
+            case 18:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function processFallbackAsMemberExpression(_x5) {
+        return _processFallbackAsMemberExpression.apply(this, arguments);
+      }
+      return processFallbackAsMemberExpression;
+    }()
+  }, {
+    key: "processFallbackAsTemplateLiteral",
+    value: function () {
+      var _processFallbackAsTemplateLiteral = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(fallbackValueNode) {
+        var expressions, rawFallbackValue, fallbackValue, quasis, exprValue, expression, resolvedImportDeclaration, resolvedLocalVarDeclaration, result, _result;
+        return _regeneratorRuntime.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              expressions = fallbackValueNode.expressions;
+              rawFallbackValue = '';
+              quasis = fallbackValueNode.quasis;
+              if (!(expressions.length !== 1 || quasis.length !== 2)) {
+                _context6.next = 6;
+                break;
+              }
+              this.logError("Unsupported template literal structure");
+              return _context6.abrupt("return", {
+                rawFallbackValue: rawFallbackValue,
+                fallbackValue: fallbackValue,
+                resolvedImportDeclaration: undefined,
+                resolvedLocalVarDeclaration: undefined
+              });
+            case 6:
+              expression = expressions[0];
+              if (!(expression.type === 'Identifier')) {
+                _context6.next = 16;
+                break;
+              }
+              _context6.next = 10;
+              return this.processFallbackAsIdentifier(expression);
+            case 10:
+              result = _context6.sent;
+              exprValue = result.fallbackValue;
+              resolvedImportDeclaration = result.resolvedImportDeclaration;
+              resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
+              _context6.next = 22;
+              break;
+            case 16:
+              if (!(expression.type === 'MemberExpression')) {
+                _context6.next = 22;
+                break;
+              }
+              _context6.next = 19;
+              return this.processFallbackAsMemberExpression(expression);
+            case 19:
+              _result = _context6.sent;
+              exprValue = _result.fallbackValue;
+              resolvedImportDeclaration = _result.resolvedImportDeclaration;
+            case 22:
+              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);
+                this.logVerbose("Resolved fallback value from template literal: ".concat(chalk.yellow(fallbackValue)));
+              }
+              return _context6.abrupt("return", {
+                rawFallbackValue: rawFallbackValue,
+                fallbackValue: fallbackValue,
+                resolvedImportDeclaration: resolvedImportDeclaration,
+                resolvedLocalVarDeclaration: resolvedLocalVarDeclaration
+              });
+            case 24:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function processFallbackAsTemplateLiteral(_x6) {
+        return _processFallbackAsTemplateLiteral.apply(this, arguments);
+      }
+      return processFallbackAsTemplateLiteral;
+    }()
+  }, {
+    key: "tryResolveModulePath",
+    value: function tryResolveModulePath(moduleName) {
+      try {
+        var resolvedPath = require.resolve(moduleName, {
+          paths: [this.rootDir]
+        });
+        this.logVerbose("Resolved module path: ".concat(chalk.green(resolvedPath), " for ").concat(chalk.cyan(moduleName)));
+        return resolvedPath;
+      } catch (error) {
+        return null;
+      }
+    }
+  }, {
+    key: "tryResolveLocalPath",
+    value: function () {
+      var _tryResolveLocalPath = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7(currentDir, importPath) {
+        var _iterator, _step, ext, potentialPath;
+        return _regeneratorRuntime.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _iterator = _createForOfIteratorHelper(this.possibleExtensions);
+              _context7.prev = 1;
+              _iterator.s();
+            case 3:
+              if ((_step = _iterator.n()).done) {
+                _context7.next = 17;
+                break;
+              }
+              ext = _step.value;
+              potentialPath = path.resolve(currentDir, "".concat(importPath).concat(ext));
+              _context7.prev = 6;
+              _context7.next = 9;
+              return fs.access(potentialPath);
+            case 9:
+              this.logVerbose("Resolved file path locally: ".concat(chalk.green(potentialPath)));
+              return _context7.abrupt("return", potentialPath);
+            case 13:
+              _context7.prev = 13;
+              _context7.t0 = _context7["catch"](6);
+            case 15:
+              _context7.next = 3;
+              break;
+            case 17:
+              _context7.next = 22;
+              break;
+            case 19:
+              _context7.prev = 19;
+              _context7.t1 = _context7["catch"](1);
+              _iterator.e(_context7.t1);
+            case 22:
+              _context7.prev = 22;
+              _iterator.f();
+              return _context7.finish(22);
+            case 25:
+              return _context7.abrupt("return", null);
+            case 26:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[1, 19, 22, 25], [6, 13]]);
+      }));
+      function tryResolveLocalPath(_x7, _x8) {
+        return _tryResolveLocalPath.apply(this, arguments);
+      }
+      return tryResolveLocalPath;
+    }()
+  }, {
+    key: "resolveValueFromImport",
+    value: function () {
+      var _resolveValueFromImport = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8(currentDir, importPath, objectName, propertyOrVariableName) {
+        var filePath, fileContent, source, imports, matchingImport, _importDecl$source$va, importDecl, newImportPath, varDeclaration, init;
+        return _regeneratorRuntime.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              filePath = this.tryResolveModulePath(importPath);
+              if (filePath) {
+                _context8.next = 5;
+                break;
+              }
+              _context8.next = 4;
+              return this.tryResolveLocalPath(currentDir, importPath);
+            case 4:
+              filePath = _context8.sent;
+            case 5:
+              if (filePath) {
+                _context8.next = 8;
+                break;
+              }
+              this.logError("File not found for import path: ".concat(chalk.cyan(importPath), " in directory: ").concat(chalk.blue(this.rootDir)));
+              return _context8.abrupt("return", undefined);
+            case 8:
+              this.logVerbose("Reading file: ".concat(chalk.green(filePath)));
+              _context8.next = 11;
+              return fs.readFile(filePath, 'utf-8');
+            case 11:
+              fileContent = _context8.sent;
+              source = this.j(fileContent);
+              if (!objectName) {
+                _context8.next = 20;
+                break;
+              }
+              // Check if the object is imported from another module
+              imports = source.find(this.j.ImportDeclaration);
+              matchingImport = imports.filter(this.createImportFilter(objectName)).at(0);
+              if (!matchingImport.size()) {
+                _context8.next = 20;
+                break;
+              }
+              importDecl = matchingImport.get().node;
+              newImportPath = (_importDecl$source$va = importDecl.source.value) === null || _importDecl$source$va === void 0 ? void 0 : _importDecl$source$va.toString();
+              return _context8.abrupt("return", this.resolveValueFromImport(path.dirname(filePath), newImportPath, objectName, propertyOrVariableName));
+            case 20:
+              // If not imported, check for variable declaration
+              varDeclaration = source.find(this.j.VariableDeclarator, {
+                id: {
+                  name: propertyOrVariableName
+                }
+              }).at(0);
+              if (varDeclaration.size()) {
+                _context8.next = 24;
+                break;
+              }
+              this.logError("Variable declaration not found for ".concat(chalk.yellow(propertyOrVariableName), " in file: ").concat(chalk.green(filePath)));
+              return _context8.abrupt("return", undefined);
+            case 24:
+              init = varDeclaration.get().value.init;
+              if (!(init.type === 'Literal' || init.type === 'StringLiteral' || init.type === 'NumericLiteral')) {
+                _context8.next = 29;
+                break;
+              }
+              return _context8.abrupt("return", init.value);
+            case 29:
+              this.logError("Unhandled init type ".concat(init.type, " for variable: ").concat(chalk.yellow(propertyOrVariableName), " in file: ").concat(chalk.green(filePath)));
+              return _context8.abrupt("return", undefined);
+            case 31:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function resolveValueFromImport(_x9, _x10, _x11, _x12) {
+        return _resolveValueFromImport.apply(this, arguments);
+      }
+      return resolveValueFromImport;
+    }()
+  }, {
+    key: "createImportFilter",
+    value: function createImportFilter(targetName) {
+      return function (path) {
+        var _path$node$specifiers;
+        return ((_path$node$specifiers = path.node.specifiers) === null || _path$node$specifiers === void 0 ? void 0 : _path$node$specifiers.some(function (specifier) {
+          var _specifier$local, _specifier$local2, _specifier$local3;
+          switch (specifier.type) {
+            case 'ImportNamespaceSpecifier':
+              return ((_specifier$local = specifier.local) === null || _specifier$local === void 0 ? void 0 : _specifier$local.name) === targetName;
+            case 'ImportDefaultSpecifier':
+              return ((_specifier$local2 = specifier.local) === null || _specifier$local2 === void 0 ? void 0 : _specifier$local2.name) === targetName;
+            case 'ImportSpecifier':
+              return ((_specifier$local3 = specifier.local) === null || _specifier$local3 === void 0 ? void 0 : _specifier$local3.name) === targetName || specifier.imported.name === targetName;
+            default:
+              return false;
+          }
+        })) === true;
+      };
+    }
+  }]);
+}();

package/dist/esm/presets/remove-token-fallbacks/utils/update-comments.js

@@ -0,0 +1,51 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+export function addOrUpdateEslintIgnoreComment(j, tokenValue, fallbackValue, callPath) {
+  var commentText = "eslint-disable-next-line @atlaskit/design-system/no-unsafe-design-token-usage -- The token value \"".concat(tokenValue, "\" and fallback \"").concat(fallbackValue, "\" do not match and can't be replaced automatically.");
+  // first see if we can add the comment to the parent object property
+  var updatedCommentInObjectExpression = addOrUpdateEslintIgnoreCommentForParentInObjectExpression(j, commentText, callPath);
+  // if the comment was not added to the parent object property, add it to the node itself
+  if (!updatedCommentInObjectExpression) {
+    addOrUpdateEslintIgnoreCommentForNodeItself(j, commentText, callPath);
+  }
+}
+function addOrUpdateEslintIgnoreCommentForNodeItself(j, commentText, callPath) {
+  var leadingComments = callPath.node.leadingComments || [];
+  var existingCommentIndex = leadingComments.findIndex(function (comment) {
+    return comment.value.includes('eslint-disable-next-line @atlaskit/design-system/no-unsafe-design-token-usage');
+  });
+  var commentLine = j.commentLine(commentText, true);
+  if (existingCommentIndex !== -1) {
+    // Replace the existing comment
+    // Note: in order to modify the comment, it's fine to update it in the `leadingComments` array
+    leadingComments[existingCommentIndex] = commentLine;
+  } else {
+    // Add a new comment if none exists
+    // Note: Adding new comment to 'leadingComments' doesn't affect anything, we need to add it to 'comments' property
+    callPath.node.comments = [commentLine];
+  }
+}
+function addOrUpdateEslintIgnoreCommentForParentInObjectExpression(j, commentText, callPath) {
+  var parent = callPath.parentPath;
+  // Check if the parent node is an ObjectProperty
+  if (parent && parent.node.type === 'ObjectProperty') {
+    var grandparent = parent.parentPath;
+    // Check if the grandparent is an ObjectExpression
+    if (grandparent && grandparent.node.type === 'ObjectExpression') {
+      // Check for existing leading comments
+      var leadingComments = parent.node.leadingComments || [];
+      var existingCommentIndex = leadingComments.findIndex(function (comment) {
+        return comment.value.includes('eslint-disable-next-line @atlaskit/design-system/no-unsafe-design-token-usage');
+      });
+      var commentLine = j.commentLine(commentText, true);
+      if (existingCommentIndex !== -1) {
+        // Replace the existing comment
+        leadingComments[existingCommentIndex] = commentLine;
+      } else {
+        // Add a new comment if none exists
+        parent.node.comments = [commentLine].concat(_toConsumableArray(parent.node.comments || []));
+      }
+      return true;
+    }
+  }
+  return false;
+}