@atlaskit/codemod-cli 0.27.2 → 0.27.3

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

@@ -0,0 +1,58 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addOrUpdateEslintIgnoreComment = addOrUpdateEslintIgnoreComment;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+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((0, _toConsumableArray2.default)(parent.node.comments || []));
+      }
+      return true;
+    }
+  }
+  return false;
+}

package/dist/es2019/main.js

@@ -106,9 +106,22 @@ const runTransform = async (filePaths, transform, flags) => {
   const jscodeshiftContent = fs.readFileSync(jscodeshift, 'utf8');
   const jscodeshiftContentNew = fixLineEnding(jscodeshiftContent, 'LF');
   fs.writeFileSync(jscodeshift, jscodeshiftContentNew);
+  let transformModule;
+  try {
+    transformModule = require(transformPath);
+  } catch (error) {
+    // eslint-disable-next-line no-console
+    console.warn(`Error loading transform module: ${transformPath}. Skipping lifecycle hooks.`);
+  }
+  if (transformModule) {
+    await processLifecycleHook('beforeAll', transformModule, logger, transform, flags);
+  }
   await spawn(jscodeshift, args, {
     stdio: 'inherit'
   });
+  if (transformModule) {
+    await processLifecycleHook('afterAll', transformModule, logger, transform, flags);
+  }
 };
 const parsePkg = pkg => {
   if (!pkg.startsWith('@')) {
@@ -179,6 +192,17 @@ const defaultFlags = {
   ignorePattern: 'node_modules',
   logger: console
 };
+async function processLifecycleHook(hookName, transformModule, logger, transform, flags) {
+  if (typeof transformModule[hookName] === 'function') {
+    try {
+      logger.log(chalk.green(`Executing ${hookName} for transform '${transform.name}'...`));
+      await transformModule[hookName](flags);
+    } catch (error) {
+      logger.log(chalk.red(`Error in ${hookName} for transform '${transform.name}': ${error}`));
+      throw error; // Re-throw error for beforeAll to halt execution
+    }
+  }
+}
 export default async function main(input, userFlags) {
   const flags = {
     ...defaultFlags,

package/dist/es2019/presets/index.js

@@ -10,5 +10,6 @@ import './migrate-to-link/migrate-to-link';
 import './migrate-to-new-buttons/migrate-to-new-buttons';
 import './upgrade-pragmatic-drag-and-drop-to-stable/upgrade-pragmatic-drag-and-drop-to-stable';
 import './remove-dark-theme-vr-options/remove-dark-theme-vr-options';
-const presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
+import './remove-token-fallbacks/remove-token-fallbacks';
+const presets = ['styled-to-emotion', 'theme-remove-deprecated-mixins', 'migrate-to-link', 'migrate-to-new-buttons', 'upgrade-pragmatic-drag-and-drop-to-stable', 'remove-dark-theme-vr-options', 'remove-token-fallbacks'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
 export default presets;

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

@@ -0,0 +1,130 @@
+/* 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';
+const 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 async function transformer(fileInfo, {
+  jscodeshift: j
+}, options) {
+  var _options$useLegacyCol;
+  const rootDir = await findRoot(path.dirname(fileInfo.path));
+  const source = j(fileInfo.source);
+  if (!hasImportDeclaration(j, source, '@atlaskit/tokens')) {
+    return fileInfo.source;
+  }
+  const details = {
+    replaced: [],
+    notReplaced: []
+  };
+  if (options.verbose) {
+    console.log(chalk.yellow(`Using ${options.useLegacyColorTheme ? 'legacy light' : 'light'} theme.`));
+  }
+  const tokenMap = getTokenMap((_options$useLegacyCol = options.useLegacyColorTheme) !== null && _options$useLegacyCol !== void 0 ? _options$useLegacyCol : false);
+  const teamInfo = await getTeamInfo(fileInfo.path);
+  const transformPromises = source.find(j.CallExpression, {
+    callee: {
+      type: 'Identifier',
+      name: 'token'
+    }
+  }).paths().map(callPath => {
+    const processor = new TokenProcessor(j, options, fileInfo, source, rootDir, details, tokenMap, teamInfo);
+    return processor.processAndLogSingleToken(callPath);
+  });
+  const results = await Promise.all(transformPromises);
+  const unusedVars = [];
+  if (results.some(result => result.fallbackRemoved)) {
+    const allImports = results.flatMap(result => {
+      var _result$resolvedImpor;
+      return (_result$resolvedImpor = result.resolvedImportDeclaration) !== null && _result$resolvedImpor !== void 0 ? _result$resolvedImpor : [];
+    });
+    const allVars = results.flatMap(result => {
+      var _result$resolvedLocal;
+      return (_result$resolvedLocal = result.resolvedLocalVarDeclaration) !== null && _result$resolvedLocal !== void 0 ? _result$resolvedLocal : [];
+    });
+    unusedVars.push(...allVars);
+    if (allImports.length) {
+      if (options.verbose) {
+        console.log(chalk.green(`${fileInfo.path}: Some fallbacks were removed. Cleaning up ${allImports.length} imports.`));
+      }
+      removeUnusedImports(allImports, j);
+    }
+  }
+  removeUnusedVariables(unusedVars, j);
+  if (options.reportFolder) {
+    await writeReports(details, options.reportFolder);
+  }
+  if (options.dry) {
+    if (options.verbose) {
+      console.log(chalk.cyan(`${fileInfo.path}: dry run mode active. Source was not modified.`));
+    }
+    // Return the unmodified source if dryRun is true
+    return fileInfo.source;
+  } else {
+    // Return the transformed source
+    return source.toSource();
+  }
+}
+export const parser = 'tsx';
+
+/**
+ * Function executed before all transformations to prepare the environment by clearing the report folder.
+ */
+export async function beforeAll(options) {
+  if (options.reportFolder) {
+    await clearFolder(options.reportFolder);
+  }
+}
+
+/**
+ * Function executed after all transformations to combine individual file reports into a comprehensive transformation report.
+ * It also applies prettier to the affected files.
+ */
+export async function afterAll(options) {
+  if (options.reportFolder) {
+    await combineReports(options.reportFolder);
+  }
+  if (options.reportFolder && !options.dry) {
+    try {
+      const filesTxtPath = path.join(options.reportFolder, 'files.txt');
+      const fileContent = await fs.readFile(filesTxtPath, 'utf-8');
+      if (fileContent.length > 0) {
+        console.log(`Running prettier on files: ${chalk.magenta(fileContent)}`);
+        await execAsync(`yarn prettier --write ${fileContent}`);
+        console.log(chalk.green(`Prettier was run successfully`));
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Unexpected error running Prettier: ${error.message}`));
+      } else {
+        console.error(chalk.red('An unknown error occurred while running Prettier.'));
+      }
+    }
+  }
+}

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

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

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

@@ -0,0 +1,30 @@
+import { legacyLightTokens as legacyLightTheme, light as lightTheme, shape as shapeTheme, spacing as spacingTheme, typographyAdg3 as typographyAdg3Theme } from '@atlaskit/tokens/tokens-raw';
+const typographyGroups = ['typography', 'fontWeight', 'fontFamily'];
+function buildCombinedMap(...arrays) {
+  const combinedMap = {};
+  arrays.forEach(array => {
+    array.forEach(token => {
+      combinedMap[token.cleanName] = token.value.toString();
+    });
+  });
+  return combinedMap;
+}
+
+// Filter the typography tokens based on predefined groups and exclusions
+const typographyAdg3ThemeFiltered = typographyAdg3Theme.filter(token => typographyGroups.includes(token.attributes.group)).filter(token => token.cleanName !== 'font.body.UNSAFE_small');
+
+// Cache array: [0] for light theme, [1] for legacy light theme
+const 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(useLegacyTheme = false) {
+  const themeIndex = useLegacyTheme ? 1 : 0;
+  if (!tokenMapCache[themeIndex]) {
+    const selectedTheme = useLegacyTheme ? legacyLightTheme : lightTheme;
+    tokenMapCache[themeIndex] = buildCombinedMap(selectedTheme, spacingTheme, shapeTheme, typographyAdg3ThemeFiltered);
+  }
+  return tokenMapCache[themeIndex];
+}

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

@@ -0,0 +1,84 @@
+import { diff, rgb_to_lab } from 'color-diff';
+
+// Compare hex values using a CIEDE2000 color difference algorithm
+export const compareHex = (hex, hex2) => 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
+  const r = parseInt(hex.substring(0, 2), 16);
+  const g = parseInt(hex.substring(2, 4), 16);
+  const b = parseInt(hex.substring(4, 6), 16);
+  const a = parseInt(hex.substring(6, 8), 16) / 255;
+  return {
+    R: r,
+    G: g,
+    B: b,
+    A: a
+  };
+}
+const 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
+  const match = color.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d*\.?\d+)\s*)?\)$/i);
+  if (match) {
+    const r = parseInt(match[1], 10);
+    const g = parseInt(match[2], 10);
+    const b = parseInt(match[3], 10);
+    const a = match[4] !== undefined ? Math.round(parseFloat(match[4]) * 255) : 255;
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1).padStart(6, '0')}${a.toString(16).padStart(2, '0')}`.toUpperCase();
+  }
+  // If conversion is not possible, return the original color
+  return color;
+}

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

@@ -0,0 +1,22 @@
+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 const getTeamInfo = async filePath => {
+  var _pkgJson$packageJson$;
+  const pkgJson = await readPkgUp({
+    cwd: filePath
+  });
+  if (!pkgJson || !pkgJson.packageJson) {
+    throw new Error(`Closest package.json file could not be found or is invalid for ${filePath}.`);
+  }
+  const packageName = pkgJson.packageJson.name || '';
+  const teamName = ((_pkgJson$packageJson$ = pkgJson.packageJson.atlassian) === null || _pkgJson$packageJson$ === void 0 ? void 0 : _pkgJson$packageJson$.team) || '';
+  return {
+    packageName,
+    teamName
+  };
+};

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

@@ -0,0 +1,104 @@
+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
+const ACCEPTABLE_COLOR_DIFFERENCE = 0;
+const ACCEPTABLE_SPACE_DIFFERENCE = 0;
+const ACCEPTABLE_NUMERIC_DIFFERENCE = 0;
+export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
+  let tokenLogValue;
+  let fallbackLogValue;
+  let normalizedTokenValue = tokenValue;
+  let normalizedFallbackValue = fallbackValue;
+  const lowerCaseTokenKey = tokenKey === null || tokenKey === void 0 ? void 0 : tokenKey.toLowerCase();
+  let difference;
+  let isAcceptableDifference;
+  if (lowerCaseTokenKey.startsWith('color') || lowerCaseTokenKey.startsWith('elevation')) {
+    if (tokenValue && isValidColor(tokenValue)) {
+      const normalizedHex = colorToHex(tokenValue);
+      tokenLogValue = chalk.bgHex(normalizedHex)(tokenValue);
+      normalizedTokenValue = normalizedHex;
+    }
+    if (fallbackValue && isValidColor(fallbackValue)) {
+      const 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')) {
+    const tokenValueInPx = tokenValue ? convertToPx(tokenValue) : undefined;
+    const fallbackValueInPx = fallbackValue ? convertToPx(fallbackValue) : undefined;
+    if (tokenValueInPx !== undefined && fallbackValueInPx !== undefined) {
+      const 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
+    const tokenValueNumber = parseFloat(tokenValue !== null && tokenValue !== void 0 ? tokenValue : '');
+    const fallbackValueNumber = parseFloat(fallbackValue !== null && fallbackValue !== void 0 ? fallbackValue : '');
+    if (!isNaN(tokenValueNumber) && !isNaN(fallbackValueNumber)) {
+      const 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,
+    isAcceptableDifference,
+    tokenLogValue,
+    fallbackLogValue,
+    normalizedTokenValue,
+    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)
+  const plainNumberRegex = /^-?\d+(\.\d+)?$/;
+  if (plainNumberRegex.test(value)) {
+    return parseFloat(value);
+  }
+  // Regular expression to match CSS units
+  const unitRegex = /^(-?\d+(\.\d+)?)(px|rem|em|%)$/;
+  const match = value.match(unitRegex);
+  if (!match) {
+    return undefined;
+  }
+  const [, num,, unit] = match;
+  const 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/es2019/presets/remove-token-fallbacks/utils/remove-unused-imports.js

@@ -0,0 +1,51 @@
+export function removeUnusedImports(importDeclarations, j) {
+  const removeIfUnused = (importSpecifier, importDeclaration) => {
+    var _importSpecifier$valu;
+    const varName = (_importSpecifier$valu = importSpecifier.value.local) === null || _importSpecifier$valu === void 0 ? void 0 : _importSpecifier$valu.name;
+    if (varName === 'React' || varName === 'jsx') {
+      return false;
+    }
+    const isUsedInScopes = () => {
+      return j(importDeclaration).closestScope().find(j.Identifier, {
+        name: varName
+      }).filter(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;
+  };
+  const removeUnusedDefaultImport = importDeclaration => {
+    return j(importDeclaration).find(j.ImportDefaultSpecifier).filter(s => removeIfUnused(s, importDeclaration)).size() > 0;
+  };
+  const removeUnusedNonDefaultImports = importDeclaration => {
+    return j(importDeclaration).find(j.ImportSpecifier).filter(s => removeIfUnused(s, importDeclaration)).size() > 0;
+  };
+  const 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;
+    }
+    const hadUnusedDefaultImport = removeUnusedDefaultImport(importDeclaration);
+    const 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/es2019/presets/remove-token-fallbacks/utils/remove-unused-variables.js

@@ -0,0 +1,31 @@
+export function removeUnusedVariables(variableDeclarations, j) {
+  const removeIfUnused = varDeclarator => {
+    var _varDeclarator$value;
+    if (((_varDeclarator$value = varDeclarator.value) === null || _varDeclarator$value === void 0 ? void 0 : _varDeclarator$value.id.type) !== 'Identifier') {
+      return false;
+    }
+    const varName = varDeclarator.value.id.name;
+    const isUsedInScopes = () => {
+      return j(varDeclarator).closestScope().find(j.Identifier, {
+        name: varName
+      }).filter(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);
+}