@atlaskit/codemod-cli 0.27.2 → 0.27.3

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

@@ -0,0 +1,632 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TokenProcessor = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _promises = _interopRequireDefault(require("fs/promises"));
+var _path = _interopRequireDefault(require("path"));
+var _chalk = _interopRequireDefault(require("chalk"));
+var _normalizeValues2 = require("./normalize-values");
+var _updateComments = require("./update-comments");
+var _excluded = ["shouldLog"];
+/* eslint-disable no-console */
+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; }
+var TokenProcessor = exports.TokenProcessor = /*#__PURE__*/function () {
+  function TokenProcessor(j, options, fileInfo, source, rootDir, details, tokenMap, teamInfo) {
+    (0, _classCallCheck2.default)(this, TokenProcessor);
+    (0, _defineProperty2.default)(this, "logMessages", []);
+    (0, _defineProperty2.default)(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 (0, _createClass2.default)(TokenProcessor, [{
+    key: "processAndLogSingleToken",
+    value: function () {
+      var _processAndLogSingleToken = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(callPath) {
+        var _callPath$node$loc;
+        var line, _yield$this$processSi, shouldLog, rest, coloredPath, coloredLine;
+        return _regenerator.default.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 = (0, _objectWithoutProperties2.default)(_yield$this$processSi, _excluded);
+              if (!(this.options.silent || !shouldLog)) {
+                _context.next = 8;
+                break;
+              }
+              return _context.abrupt("return", rest);
+            case 8:
+              coloredPath = _chalk.default.blue(this.fileInfo.path);
+              coloredLine = line ? ": ".concat(_chalk.default.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.default.red(message));
+    }
+  }, {
+    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;
+        return _regenerator.default.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.default.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.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;
+              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;
+              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.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);
+                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) {
+                  (0, _updateComments.addOrUpdateEslintIgnoreComment)(this.j, tokenValue, fallbackValue, callPath);
+                }
+                this.details.notReplaced.push(logData);
+              }
+              this.log("Token: ".concat(_chalk.default.yellow(tokenKey), ", Raw fallback: ").concat(_chalk.default.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.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(fallbackValueNode) {
+        return _regenerator.default.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.default.yellow(fallbackValue)));
+      return {
+        fallbackValue: fallbackValue,
+        rawFallbackValue: fallbackValue,
+        resolvedImportDeclaration: undefined,
+        resolvedLocalVarDeclaration: undefined
+      };
+    }
+  }, {
+    key: "processFallbackAsIdentifier",
+    value: function () {
+      var _processFallbackAsIdentifier = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(fallbackValueNode) {
+        var variableName, variableNameForLog, fallbackValue, localVarDeclaration, resolvedImportDeclaration, resolvedLocalVarDeclaration, init, importDeclaration, importSource;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              variableName = fallbackValueNode.name;
+              variableNameForLog = "".concat(_chalk.default.yellow(variableName));
+              this.logVerbose("Fallback is an identifier: ".concat(_chalk.default.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.default.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.default.yellow(fallbackValue), " for identifier: ").concat(variableNameForLog));
+                resolvedImportDeclaration = importDeclaration.paths()[0];
+              }
+              _context4.next = 19;
+              break;
+            case 18:
+              this.logVerbose(_chalk.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(fallbackValueNode) {
+        var objectName, propertyName, fallbackValue, rawFallbackValue, resolvedImportDeclaration, importDeclaration, importSource;
+        return _regenerator.default.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.default.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.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;
+                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.default.yellow(fallbackValue)));
+              }
+              _context5.next = 17;
+              break;
+            case 16:
+              this.logError("Could not find import for member expression: ".concat(_chalk.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(fallbackValueNode) {
+        var expressions, rawFallbackValue, fallbackValue, quasis, exprValue, expression, resolvedImportDeclaration, resolvedLocalVarDeclaration, result, _result;
+        return _regenerator.default.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.default.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.default.green(resolvedPath), " for ").concat(_chalk.default.cyan(moduleName)));
+        return resolvedPath;
+      } catch (error) {
+        return null;
+      }
+    }
+  }, {
+    key: "tryResolveLocalPath",
+    value: function () {
+      var _tryResolveLocalPath = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(currentDir, importPath) {
+        var _iterator, _step, ext, potentialPath;
+        return _regenerator.default.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.default.resolve(currentDir, "".concat(importPath).concat(ext));
+              _context7.prev = 6;
+              _context7.next = 9;
+              return _promises.default.access(potentialPath);
+            case 9:
+              this.logVerbose("Resolved file path locally: ".concat(_chalk.default.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(currentDir, importPath, objectName, propertyOrVariableName) {
+        var filePath, fileContent, source, imports, matchingImport, _importDecl$source$va, importDecl, newImportPath, varDeclaration, init;
+        return _regenerator.default.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.default.cyan(importPath), " in directory: ").concat(_chalk.default.blue(this.rootDir)));
+              return _context8.abrupt("return", undefined);
+            case 8:
+              this.logVerbose("Reading file: ".concat(_chalk.default.green(filePath)));
+              _context8.next = 11;
+              return _promises.default.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.default.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.default.yellow(propertyOrVariableName), " in file: ").concat(_chalk.default.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.default.yellow(propertyOrVariableName), " in file: ").concat(_chalk.default.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;
+      };
+    }
+  }]);
+}();