@atlaskit/codemod-cli 0.27.1 → 0.27.3

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

@@ -0,0 +1,215 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+/* eslint-disable no-console */
+import { exec } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { hasImportDeclaration } from '@hypermod/utils';
+import { findRoot } from '@manypkg/find-root';
+import chalk from 'chalk';
+import { getTokenMap } from './utils/all-tokens';
+import { getTeamInfo } from './utils/get-team-info';
+import { removeUnusedImports } from './utils/remove-unused-imports';
+import { removeUnusedVariables } from './utils/remove-unused-variables';
+import { clearFolder, combineReports, writeReports } from './utils/reporter';
+import { TokenProcessor } from './utils/token-processor';
+var execAsync = promisify(exec);
+
+/**
+ * Transforms the source code of a file by removing fallback values from the @atlaskit/tokens/token functions.
+ * By default removes only the fallbacks that have the same values as the tokens.
+ *
+ * @param {FileInfo} fileInfo - Information about the file to be transformed.
+ * @param {API} api - The jscodeshift API, providing utilities for AST transformations.
+ * @param {RemoveTokenFallbackOptions} options - Options for the transformation, including:
+ *   @param {boolean} [options.verbose] - If true, enables verbose logging.
+ *   @param {boolean} [options.forceUpdate] - If true, removes the fallbacks regardless of the difference between token and fallback. Otherwise removes only the fallbacks that are equal to the token values.
+ *   @param {boolean} [options.addEslintComments] - If true, adds the eslint ignore comment for the rule @atlaskit/design-system/no-unsafe-design-token-usage for the fallbacks that weren't removed.
+ *   @param {boolean} [options.useLegacyColorTheme] - If true, uses the legacy theme for color token mapping.
+ *   @param {string} [options.reportFolder] - Directory path to output transformation reports. Reports will be generated only if this option is provided.
+ *   @param {boolean} [options.dry] - If true, performs a dry run without modifying the files.
+ *
+ * @returns {Promise<string>} A promise that resolves to the transformed source code as a string.
+ */
+export default function transformer(_x, _x2, _x3) {
+  return _transformer.apply(this, arguments);
+}
+function _transformer() {
+  _transformer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(fileInfo, _ref, options) {
+    var _options$useLegacyCol;
+    var j, rootDir, source, details, tokenMap, teamInfo, transformPromises, results, unusedVars, allImports, allVars;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          j = _ref.jscodeshift;
+          _context.next = 3;
+          return findRoot(path.dirname(fileInfo.path));
+        case 3:
+          rootDir = _context.sent;
+          source = j(fileInfo.source);
+          if (hasImportDeclaration(j, source, '@atlaskit/tokens')) {
+            _context.next = 7;
+            break;
+          }
+          return _context.abrupt("return", fileInfo.source);
+        case 7:
+          details = {
+            replaced: [],
+            notReplaced: []
+          };
+          if (options.verbose) {
+            console.log(chalk.yellow("Using ".concat(options.useLegacyColorTheme ? 'legacy light' : 'light', " theme.")));
+          }
+          tokenMap = getTokenMap((_options$useLegacyCol = options.useLegacyColorTheme) !== null && _options$useLegacyCol !== void 0 ? _options$useLegacyCol : false);
+          _context.next = 12;
+          return getTeamInfo(fileInfo.path);
+        case 12:
+          teamInfo = _context.sent;
+          transformPromises = source.find(j.CallExpression, {
+            callee: {
+              type: 'Identifier',
+              name: 'token'
+            }
+          }).paths().map(function (callPath) {
+            var processor = new TokenProcessor(j, options, fileInfo, source, rootDir, details, tokenMap, teamInfo);
+            return processor.processAndLogSingleToken(callPath);
+          });
+          _context.next = 16;
+          return Promise.all(transformPromises);
+        case 16:
+          results = _context.sent;
+          unusedVars = [];
+          if (results.some(function (result) {
+            return result.fallbackRemoved;
+          })) {
+            allImports = results.flatMap(function (result) {
+              var _result$resolvedImpor;
+              return (_result$resolvedImpor = result.resolvedImportDeclaration) !== null && _result$resolvedImpor !== void 0 ? _result$resolvedImpor : [];
+            });
+            allVars = results.flatMap(function (result) {
+              var _result$resolvedLocal;
+              return (_result$resolvedLocal = result.resolvedLocalVarDeclaration) !== null && _result$resolvedLocal !== void 0 ? _result$resolvedLocal : [];
+            });
+            unusedVars.push.apply(unusedVars, _toConsumableArray(allVars));
+            if (allImports.length) {
+              if (options.verbose) {
+                console.log(chalk.green("".concat(fileInfo.path, ": Some fallbacks were removed. Cleaning up ").concat(allImports.length, " imports.")));
+              }
+              removeUnusedImports(allImports, j);
+            }
+          }
+          removeUnusedVariables(unusedVars, j);
+          if (!options.reportFolder) {
+            _context.next = 23;
+            break;
+          }
+          _context.next = 23;
+          return writeReports(details, options.reportFolder);
+        case 23:
+          if (!options.dry) {
+            _context.next = 28;
+            break;
+          }
+          if (options.verbose) {
+            console.log(chalk.cyan("".concat(fileInfo.path, ": dry run mode active. Source was not modified.")));
+          }
+          // Return the unmodified source if dryRun is true
+          return _context.abrupt("return", fileInfo.source);
+        case 28:
+          return _context.abrupt("return", source.toSource());
+        case 29:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _transformer.apply(this, arguments);
+}
+export var parser = 'tsx';
+
+/**
+ * Function executed before all transformations to prepare the environment by clearing the report folder.
+ */
+export function beforeAll(_x4) {
+  return _beforeAll.apply(this, arguments);
+}
+
+/**
+ * Function executed after all transformations to combine individual file reports into a comprehensive transformation report.
+ * It also applies prettier to the affected files.
+ */
+function _beforeAll() {
+  _beforeAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(options) {
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          if (!options.reportFolder) {
+            _context2.next = 3;
+            break;
+          }
+          _context2.next = 3;
+          return clearFolder(options.reportFolder);
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _beforeAll.apply(this, arguments);
+}
+export function afterAll(_x5) {
+  return _afterAll.apply(this, arguments);
+}
+function _afterAll() {
+  _afterAll = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(options) {
+    var filesTxtPath, fileContent;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          if (!options.reportFolder) {
+            _context3.next = 3;
+            break;
+          }
+          _context3.next = 3;
+          return combineReports(options.reportFolder);
+        case 3:
+          if (!(options.reportFolder && !options.dry)) {
+            _context3.next = 19;
+            break;
+          }
+          _context3.prev = 4;
+          filesTxtPath = path.join(options.reportFolder, 'files.txt');
+          _context3.next = 8;
+          return fs.readFile(filesTxtPath, 'utf-8');
+        case 8:
+          fileContent = _context3.sent;
+          if (!(fileContent.length > 0)) {
+            _context3.next = 14;
+            break;
+          }
+          console.log("Running prettier on files: ".concat(chalk.magenta(fileContent)));
+          _context3.next = 13;
+          return execAsync("yarn prettier --write ".concat(fileContent));
+        case 13:
+          console.log(chalk.green("Prettier was run successfully"));
+        case 14:
+          _context3.next = 19;
+          break;
+        case 16:
+          _context3.prev = 16;
+          _context3.t0 = _context3["catch"](4);
+          if (_context3.t0 instanceof Error) {
+            console.error(chalk.red("Unexpected error running Prettier: ".concat(_context3.t0.message)));
+          } else {
+            console.error(chalk.red('An unknown error occurred while running Prettier.'));
+          }
+        case 19:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[4, 16]]);
+  }));
+  return _afterAll.apply(this, arguments);
+}

package/dist/esm/presets/remove-token-fallbacks/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,38 @@
+import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typographyAdg3 as typographyAdg3Theme } from '@atlaskit/tokens/tokens-raw';
+var typographyGroups = ['typography', 'fontWeight', 'fontFamily'];
+function buildCombinedMap() {
+  var combinedMap = {};
+  for (var _len = arguments.length, arrays = new Array(_len), _key = 0; _key < _len; _key++) {
+    arrays[_key] = arguments[_key];
+  }
+  arrays.forEach(function (array) {
+    array.forEach(function (token) {
+      combinedMap[token.cleanName] = token.value.toString();
+    });
+  });
+  return combinedMap;
+}
+
+// Filter the typography tokens based on predefined groups and exclusions
+var typographyAdg3ThemeFiltered = typographyAdg3Theme.filter(function (token) {
+  return typographyGroups.includes(token.attributes.group);
+}).filter(function (token) {
+  return token.cleanName !== 'font.body.UNSAFE_small';
+});
+
+// Cache array: [0] for light theme, [1] for legacy light theme
+var tokenMapCache = [null, null];
+
+// Function to get the token map with the desired theme.
+// This should be used with the same value as the @atlaskit/tokens/babel-plugin is cofigured with for the given path.
+// When there is no theme, the babel plugin would use the given theme to provide default token fallbacks. Therefore it's safe to remove fallbacks only when they match the fallbacks that would be generated by the babel plugin with the given theme.
+// The default value is set to use the Light theme to match the behavior of the babel plugin (packages/design-system/tokens/src/babel-plugin/plugin.tsx).
+export function getTokenMap() {
+  var useLegacyTheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var themeIndex = useLegacyTheme ? 1 : 0;
+  if (!tokenMapCache[themeIndex]) {
+    var selectedTheme = useLegacyTheme ? legacyLightTheme : lightTheme;
+    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyAdg3ThemeFiltered);
+  }
+  return tokenMapCache[themeIndex];
+}

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

@@ -0,0 +1,86 @@
+import { diff, rgb_to_lab } from 'color-diff';
+
+// Compare hex values using a CIEDE2000 color difference algorithm
+export var compareHex = function compareHex(hex, hex2) {
+  return diff(rgb_to_lab(hexToRgbA(hex)), rgb_to_lab(hexToRgbA(hex2)));
+};
+function hexToRgbA(hex) {
+  // Remove the leading '#' if present
+  hex = hex.replace(/^#/, '');
+  // Parse the hex string
+  var r = parseInt(hex.substring(0, 2), 16);
+  var g = parseInt(hex.substring(2, 4), 16);
+  var b = parseInt(hex.substring(4, 6), 16);
+  var a = parseInt(hex.substring(6, 8), 16) / 255;
+  return {
+    R: r,
+    G: g,
+    B: b,
+    A: a
+  };
+}
+var namedColors = {
+  black: '#000000',
+  silver: '#C0C0C0',
+  gray: '#808080',
+  grey: '#808080',
+  pink: '#FFC0CB',
+  white: '#FFFFFF',
+  maroon: '#800000',
+  red: '#FF0000',
+  purple: '#800080',
+  fuchsia: '#FF00FF',
+  green: '#008000',
+  lime: '#00FF00',
+  olive: '#808000',
+  yellow: '#FFFF00',
+  navy: '#000080',
+  blue: '#0000FF',
+  teal: '#008080',
+  aqua: '#00FFFF'
+};
+export function isValidColor(color) {
+  // Check if it's a named color
+  if (namedColors[color.toLowerCase()]) {
+    return true;
+  }
+  // Check for hex colors (including those with alpha)
+  if (/^#([0-9A-F]{3}){1,2}([0-9A-F]{2})?$/i.test(color)) {
+    return true;
+  }
+  // Check for rgba() values
+  if (/^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+\s*(?:,\s*(?:0?\.)?\d+\s*)?\)$/i.test(color)) {
+    return true;
+  }
+  return false;
+}
+export function colorToHex(color) {
+  // Handle named colors
+  if (namedColors[color.toLowerCase()]) {
+    return namedColors[color.toLowerCase()].toUpperCase() + 'FF'; // Add full opacity
+  }
+  if (color.startsWith('#')) {
+    // If it's already a hex color
+    if (color.length === 7) {
+      // #RRGGBB format, add full opacity
+      return (color + 'FF').toUpperCase();
+    } else if (color.length === 9) {
+      // #RRGGBBAA format, return as is
+      return color.toUpperCase();
+    } else if (color.length === 4) {
+      // #RGB format, expand to #RRGGBBFF
+      return ('#' + color[1] + color[1] + color[2] + color[2] + color[3] + color[3] + 'FF').toUpperCase();
+    }
+  }
+  // For rgb() and rgba(), convert to hex
+  var match = color.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?\)$/i);
+  if (match) {
+    var r = parseInt(match[1], 10);
+    var g = parseInt(match[2], 10);
+    var b = parseInt(match[3], 10);
+    var a = match[4] !== undefined ? Math.round(parseFloat(match[4]) * 255) : 255;
+    return "#".concat(((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).padStart(6, '0')).concat(a.toString(16).padStart(2, '0')).toUpperCase();
+  }
+  // If conversion is not possible, return the original color
+  return color;
+}

package/dist/esm/presets/remove-token-fallbacks/utils/get-team-info.js

@@ -0,0 +1,44 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import readPkgUp from 'read-pkg-up';
+/**
+ * Looks for the closest package.json and gets team and package information from it.
+ *
+ * @param {string} filePath
+ * @returns {Promise<AtlassianTeamInfo>}
+ */
+export var getTeamInfo = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(filePath) {
+    var _pkgJson$packageJson$;
+    var pkgJson, packageName, teamName;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return readPkgUp({
+            cwd: filePath
+          });
+        case 2:
+          pkgJson = _context.sent;
+          if (!(!pkgJson || !pkgJson.packageJson)) {
+            _context.next = 5;
+            break;
+          }
+          throw new Error("Closest package.json file could not be found or is invalid for ".concat(filePath, "."));
+        case 5:
+          packageName = pkgJson.packageJson.name || '';
+          teamName = ((_pkgJson$packageJson$ = pkgJson.packageJson.atlassian) === null || _pkgJson$packageJson$ === void 0 ? void 0 : _pkgJson$packageJson$.team) || '';
+          return _context.abrupt("return", {
+            packageName: packageName,
+            teamName: teamName
+          });
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function getTeamInfo(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

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

@@ -0,0 +1,107 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import chalk from 'chalk';
+import { colorToHex, compareHex, isValidColor } from './color-utils';
+
+// so far allowing to remove only exact matches in values. Can be increased to auto-remove fallbacks with similar values
+var ACCEPTABLE_COLOR_DIFFERENCE = 0;
+var ACCEPTABLE_SPACE_DIFFERENCE = 0;
+var ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
+export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
+  var tokenLogValue;
+  var fallbackLogValue;
+  var normalizedTokenValue = tokenValue;
+  var normalizedFallbackValue = fallbackValue;
+  var lowerCaseTokenKey = tokenKey === null || tokenKey === void 0 ? void 0 : tokenKey.toLowerCase();
+  var difference;
+  var isAcceptableDifference;
+  if (lowerCaseTokenKey.startsWith('color') || lowerCaseTokenKey.startsWith('elevation')) {
+    if (tokenValue && isValidColor(tokenValue)) {
+      var normalizedHex = colorToHex(tokenValue);
+      tokenLogValue = chalk.bgHex(normalizedHex)(tokenValue);
+      normalizedTokenValue = normalizedHex;
+    }
+    if (fallbackValue && isValidColor(fallbackValue)) {
+      var _normalizedHex = colorToHex(fallbackValue);
+      fallbackLogValue = chalk.bgHex(_normalizedHex)(fallbackValue);
+      normalizedFallbackValue = _normalizedHex;
+    }
+    if (normalizedTokenValue && normalizedFallbackValue) {
+      difference = compareHex(normalizedTokenValue, normalizedFallbackValue);
+      isAcceptableDifference = difference <= ACCEPTABLE_COLOR_DIFFERENCE;
+    }
+  } else if (lowerCaseTokenKey.startsWith('space')) {
+    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;
+    }
+    // Log the normalized values
+    normalizedTokenValue = tokenValue;
+    normalizedFallbackValue = fallbackValue;
+    tokenLogValue = tokenValue;
+    fallbackLogValue = fallbackValue;
+  } else {
+    // Handle other numeric comparisons
+    var tokenValueNumber = parseFloat(tokenValue !== null && tokenValue !== void 0 ? tokenValue : '');
+    var fallbackValueNumber = parseFloat(fallbackValue !== null && fallbackValue !== void 0 ? fallbackValue : '');
+    if (!isNaN(tokenValueNumber) && !isNaN(fallbackValueNumber)) {
+      var _maxVal = Math.max(tokenValueNumber, fallbackValueNumber);
+      difference = Math.abs(tokenValueNumber - fallbackValueNumber) / _maxVal * 100;
+      isAcceptableDifference = difference <= ACCEPTABLE_NUMERIC_DIFFERENCE;
+    }
+    // Log the normalized values
+    normalizedTokenValue = tokenValue;
+    normalizedFallbackValue = fallbackValue;
+    tokenLogValue = tokenValue;
+    fallbackLogValue = fallbackValue;
+  }
+  if (tokenLogValue === undefined) {
+    tokenLogValue = chalk.magenta(tokenValue || '');
+  }
+  if (fallbackLogValue === undefined) {
+    fallbackLogValue = chalk.yellow(fallbackValue || '');
+  }
+  return {
+    difference: difference,
+    isAcceptableDifference: isAcceptableDifference,
+    tokenLogValue: tokenLogValue,
+    fallbackLogValue: fallbackLogValue,
+    normalizedTokenValue: normalizedTokenValue,
+    normalizedFallbackValue: normalizedFallbackValue
+  };
+}
+function convertToPx(value) {
+  // If the value is a number, return it directly
+  if (typeof value === 'number') {
+    return value;
+  }
+  // Check if the string is a plain number (without units)
+  var plainNumberRegex = /^-?\d+(\.\d+)?$/;
+  if (plainNumberRegex.test(value)) {
+    return parseFloat(value);
+  }
+  // Regular expression to match CSS units
+  var unitRegex = /^(-?\d+(\.\d+)?)(px|rem|em|%)$/;
+  var match = value.match(unitRegex);
+  if (!match) {
+    return undefined;
+  }
+  var _match = _slicedToArray(match, 4),
+    num = _match[1],
+    unit = _match[3];
+  var numericValue = parseFloat(num);
+  switch (unit) {
+    case 'px':
+      return numericValue;
+    case 'rem':
+      return numericValue * 16;
+    // Assuming 1rem = 16px
+    case 'em':
+      return numericValue * 16;
+    // Assuming 1em = 16px
+    default:
+      return undefined;
+  }
+}

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

@@ -0,0 +1,55 @@
+export function removeUnusedImports(importDeclarations, j) {
+  var removeIfUnused = function removeIfUnused(importSpecifier, importDeclaration) {
+    var _importSpecifier$valu;
+    var varName = (_importSpecifier$valu = importSpecifier.value.local) === null || _importSpecifier$valu === void 0 ? void 0 : _importSpecifier$valu.name;
+    if (varName === 'React' || varName === 'jsx') {
+      return false;
+    }
+    var isUsedInScopes = function isUsedInScopes() {
+      return j(importDeclaration).closestScope().find(j.Identifier, {
+        name: varName
+      }).filter(function (p) {
+        var _importSpecifier$valu2;
+        if (p.value.start === ((_importSpecifier$valu2 = importSpecifier.value.local) === null || _importSpecifier$valu2 === void 0 ? void 0 : _importSpecifier$valu2.start)) {
+          return false;
+        }
+        if (p.parentPath.value.type === 'Property' && p.name === 'key') {
+          return false;
+        }
+        if (p.name === 'property') {
+          return false;
+        }
+        return true;
+      }).size() > 0;
+    };
+    if (!isUsedInScopes()) {
+      j(importSpecifier).remove();
+      return true;
+    }
+    return false;
+  };
+  var removeUnusedDefaultImport = function removeUnusedDefaultImport(importDeclaration) {
+    return j(importDeclaration).find(j.ImportDefaultSpecifier).filter(function (s) {
+      return removeIfUnused(s, importDeclaration);
+    }).size() > 0;
+  };
+  var removeUnusedNonDefaultImports = function removeUnusedNonDefaultImports(importDeclaration) {
+    return j(importDeclaration).find(j.ImportSpecifier).filter(function (s) {
+      return removeIfUnused(s, importDeclaration);
+    }).size() > 0;
+  };
+  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) {
+      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) {
+      j(importDeclaration).remove();
+      return true;
+    }
+    return hadUnusedDefaultImport || hadUnusedNonDefaultImports;
+  };
+  importDeclarations.forEach(processImportDeclaration);
+}

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

@@ -0,0 +1,31 @@
+export function removeUnusedVariables(variableDeclarations, j) {
+  var removeIfUnused = function removeIfUnused(varDeclarator) {
+    var _varDeclarator$value;
+    if (((_varDeclarator$value = varDeclarator.value) === null || _varDeclarator$value === void 0 ? void 0 : _varDeclarator$value.id.type) !== 'Identifier') {
+      return false;
+    }
+    var varName = varDeclarator.value.id.name;
+    var isUsedInScopes = function isUsedInScopes() {
+      return j(varDeclarator).closestScope().find(j.Identifier, {
+        name: varName
+      }).filter(function (p) {
+        if (p.value.start === varDeclarator.value.id.start) {
+          return false;
+        }
+        if (p.parentPath.value.type === 'Property' && p.name === 'key') {
+          return false;
+        }
+        if (p.name === 'property') {
+          return false;
+        }
+        return true;
+      }).size() > 0;
+    };
+    if (!isUsedInScopes()) {
+      j(varDeclarator).remove();
+      return true;
+    }
+    return false;
+  };
+  variableDeclarations.forEach(removeIfUnused);
+}