@atlaskit/codemod-cli 0.27.4 → 0.28.1

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

@@ -7,6 +7,7 @@ import { hasImportDeclaration } from '@hypermod/utils';
 import { findRoot } from '@manypkg/find-root';
 import chalk from 'chalk';
 import { getTokenMap } from './utils/all-tokens';
+import { chunkArray } from './utils/chunk';
 import { getTeamInfo } from './utils/get-team-info';
 import { removeUnusedImports } from './utils/remove-unused-imports';
 import { removeUnusedVariables } from './utils/remove-unused-variables';
@@ -27,6 +28,14 @@ const execAsync = promisify(exec);
  *   @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.
+ *   @param {string} [options.skipTokens] - A comma-separated list of token prefixes to exempt from automatic fallback removal. By default, 'border' tokens are always included in this list. Whether fallbacks for these tokens are removed when they exactly match depends on the preserveSkippedFallbacks option.
+ *   @param {boolean} [options.preserveSkippedFallbacks] - If true, fallbacks for skipped tokens will never be removed, even if they exactly match the token value. If false (default), fallbacks for skipped tokens will be removed if they exactly match.
+ *   @param {boolean} [options.skipEslint] - If true, skips running ESLint on modified files after transformation.
+ *   @param {boolean} [options.skipPrettier] - If true, skips running Prettier on modified files after transformation.
+ *   @param {number} [options.colorDifferenceThreshold] - The maximum allowed difference for color tokens to be considered acceptable for removal. Default is 15.
+ *   @param {number} [options.spaceDifferenceThreshold] - The maximum allowed percentage difference for space tokens to be considered acceptable for removal. Default is 0.
+ *   @param {number} [options.numericDifferenceThreshold] - The maximum allowed percentage difference for numeric tokens to be considered acceptable for removal. Default is 0.
+ *   @param {number} [options.borderDifferenceThreshold] - The maximum allowed percentage difference for border tokens to be considered acceptable for removal. Default is 0.
  *
  * @returns {Promise<string>} A promise that resolves to the transformed source code as a string.
  */
@@ -45,6 +54,32 @@ export default async function transformer(fileInfo, {
   };
   if (options.verbose) {
     console.log(chalk.yellow(`Using ${options.useLegacyColorTheme ? 'legacy light' : 'light'} theme.`));
+    if (options.skipTokens) {
+      console.log(chalk.yellow(`Auto fallback exemptions active for: ${options.skipTokens}`));
+    }
+    if (options.preserveSkippedFallbacks) {
+      console.log(chalk.yellow(`Preserving all fallbacks for skipped tokens, even if they match exactly.`));
+    }
+    if (options.skipEslint) {
+      console.log(chalk.yellow(`Skipping ESLint post-processing.`));
+    }
+    if (options.skipPrettier) {
+      console.log(chalk.yellow(`Skipping Prettier post-processing.`));
+    }
+
+    // Log threshold values if they are set
+    if (options.colorDifferenceThreshold !== undefined) {
+      console.log(chalk.yellow(`Color difference threshold set to: ${options.colorDifferenceThreshold}`));
+    }
+    if (options.spaceDifferenceThreshold !== undefined) {
+      console.log(chalk.yellow(`Space difference threshold set to: ${options.spaceDifferenceThreshold}%`));
+    }
+    if (options.numericDifferenceThreshold !== undefined) {
+      console.log(chalk.yellow(`Numeric difference threshold set to: ${options.numericDifferenceThreshold}%`));
+    }
+    if (options.borderDifferenceThreshold !== undefined) {
+      console.log(chalk.yellow(`Border difference threshold set to: ${options.borderDifferenceThreshold}%`));
+    }
   }
   const tokenMap = getTokenMap((_options$useLegacyCol = options.useLegacyColorTheme) !== null && _options$useLegacyCol !== void 0 ? _options$useLegacyCol : false);
   const teamInfo = await getTeamInfo(fileInfo.path);
@@ -59,6 +94,9 @@ export default async function transformer(fileInfo, {
   });
   const results = await Promise.all(transformPromises);
   const unusedVars = [];
+  if (options.reportFolder) {
+    await writeReports(details, options.reportFolder);
+  }
   if (results.some(result => result.fallbackRemoved)) {
     const allImports = results.flatMap(result => {
       var _result$resolvedImpor;
@@ -75,20 +113,22 @@ export default async function transformer(fileInfo, {
       }
       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.`));
+    if (unusedVars.length) {
+      removeUnusedVariables(unusedVars, j);
     }
+    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();
+    }
+  } else {
     // Return the unmodified source if dryRun is true
     return fileInfo.source;
-  } else {
-    // Return the transformed source
-    return source.toSource();
   }
 }
 export const parser = 'tsx';
@@ -104,7 +144,7 @@ export async function beforeAll(options) {
 
 /**
  * Function executed after all transformations to combine individual file reports into a comprehensive transformation report.
- * It also applies prettier to the affected files.
+ * It also applies prettier and eslint (to remove dangling suppressions) to the affected files.
  */
 export async function afterAll(options) {
   if (options.reportFolder) {
@@ -115,16 +155,123 @@ export async function afterAll(options) {
       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`));
+        const filePaths = fileContent.split(/\r?\n/).filter(Boolean);
+
+        // Get the first file path and strip any quotes
+        const firstFilePath = filePaths[0].replace(/^['"]|['"]$/g, '');
+
+        // Determine the root directory using findRoot
+        const rootDir = await findRoot(path.dirname(firstFilePath));
+        console.log('Root directory:', rootDir);
+        await gitStage(filePaths, rootDir);
+        if (!options.skipEslint) {
+          await runEslint(filePaths, rootDir);
+        } else if (options.verbose) {
+          console.log(chalk.blue('Skipping ESLint post-processing as requested.'));
+        }
+        if (!options.skipPrettier) {
+          await runPrettier(filePaths, rootDir);
+        } else if (options.verbose) {
+          console.log(chalk.blue('Skipping Prettier post-processing as requested.'));
+        }
       }
     } catch (error) {
       if (error instanceof Error) {
-        console.error(chalk.red(`Unexpected error running Prettier: ${error.message}`));
+        console.error(chalk.red(`Unexpected error: ${error.message}`));
       } else {
-        console.error(chalk.red('An unknown error occurred while running Prettier.'));
+        console.error(chalk.red('An unknown error occurred.'));
+      }
+    }
+  }
+}
+async function gitStage(filePaths, cwd) {
+  const gitAddCommand = `git add ${filePaths.join(' ')}`;
+  console.log(`Executing command: ${gitAddCommand}`);
+  const {
+    stdout: gitAddStdout,
+    stderr: gitAddStderr
+  } = await execAsync(gitAddCommand, {
+    cwd
+  });
+  if (gitAddStdout) {
+    console.log(chalk.blue(`Git add output:\n${gitAddStdout}`));
+  }
+  if (gitAddStderr) {
+    console.error(chalk.yellow(`Git add errors:\n${gitAddStderr}`));
+  }
+  console.log(chalk.green(`All changes have been staged.`));
+}
+async function runPrettier(filePaths, cwd) {
+  const prettierCommand = `yarn prettier --write ${filePaths.join(' ')}`;
+  console.log(`Executing command: ${prettierCommand}`);
+  const {
+    stdout: prettierStdout,
+    stderr: prettierStderr
+  } = await execAsync(prettierCommand, {
+    cwd
+  });
+  if (prettierStdout) {
+    console.log(chalk.blue(`Prettier output:\n${prettierStdout}`));
+  }
+  if (prettierStderr) {
+    console.error(chalk.yellow(`Prettier errors:\n${prettierStderr}`));
+  }
+  console.log(chalk.green(`Prettier was run successfully`));
+}
+async function runEslint(filePaths, cwd) {
+  const fileChunks = chunkArray(filePaths, 20);
+  const totalChunks = fileChunks.length;
+  for (const [chunkIndex, fileChunk] of fileChunks.entries()) {
+    const eslintCommand = `yarn eslint ${fileChunk.join(' ')} --report-unused-disable-directives --fix`;
+    console.log(`Executing command for chunk ${chunkIndex + 1} of ${totalChunks}: ${eslintCommand}`);
+    try {
+      const result = await execAsync(eslintCommand, {
+        cwd
+      });
+      const {
+        stdout,
+        stderr
+      } = result;
+      if (stdout) {
+        console.log(chalk.blue(`ESLint output for chunk ${chunkIndex + 1} of ${totalChunks}:\n${stdout}`));
+      }
+      if (stderr) {
+        console.error(chalk.yellow(`ESLint errors for chunk ${chunkIndex + 1} of ${totalChunks}:\n${stderr}`));
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error running ESLint on chunk ${chunkIndex + 1} of ${totalChunks}: ${error}`));
+
+      // Retry each file individually
+      console.log(chalk.yellow(`Retrying each file in chunk ${chunkIndex + 1} of ${totalChunks} individually...`));
+
+      // Chunk the files into smaller groups of 5 for parallel retry
+      const smallerChunks = chunkArray(fileChunk, 5);
+      const totalSmallerChunks = smallerChunks.length;
+      for (const [smallChunkIndex, smallerChunk] of smallerChunks.entries()) {
+        await Promise.all(smallerChunk.map(async file => {
+          try {
+            const individualEslintCommand = `yarn eslint ${file} --report-unused-disable-directives --fix`;
+            console.log(`Executing command for file in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}: ${individualEslintCommand}`);
+            const result = await execAsync(individualEslintCommand, {
+              cwd
+            });
+            const {
+              stdout,
+              stderr
+            } = result;
+            if (stdout) {
+              console.log(chalk.blue(`ESLint output for file ${file} in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}:\n${stdout}`));
+            }
+            if (stderr) {
+              console.error(chalk.yellow(`ESLint errors for file ${file} in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}:\n${stderr}`));
+            }
+          } catch (fileError) {
+            console.error(chalk.red(`Error running ESLint on file ${file} in small chunk ${smallChunkIndex + 1} of ${totalSmallerChunks}: ${fileError}`));
+          }
+        }));
       }
     }
+    console.log(chalk.green(`Finished running ESLint for chunk ${chunkIndex + 1} of ${totalChunks}.`));
   }
+  console.log(chalk.green(`ESLint was run on all files successfully`));
 }

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

@@ -0,0 +1,8 @@
+// Utility function to split an array into chunks
+export const chunkArray = (array, chunkSize) => {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};

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

@@ -1,11 +1,17 @@
 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) {
+// Default threshold values
+const DEFAULT_COLOR_DIFFERENCE = 15;
+const DEFAULT_SPACE_DIFFERENCE = 0;
+const DEFAULT_NUMERIC_DIFFERENCE = 0;
+const DEFAULT_BORDER_DIFFERENCE = 0;
+export function normalizeValues(tokenKey, tokenValue, fallbackValue, options) {
+  // Use options thresholds or defaults
+  const colorDifference = (options === null || options === void 0 ? void 0 : options.colorDifferenceThreshold) !== undefined ? options.colorDifferenceThreshold : DEFAULT_COLOR_DIFFERENCE;
+  const spaceDifference = (options === null || options === void 0 ? void 0 : options.spaceDifferenceThreshold) !== undefined ? options.spaceDifferenceThreshold : DEFAULT_SPACE_DIFFERENCE;
+  const numericDifference = (options === null || options === void 0 ? void 0 : options.numericDifferenceThreshold) !== undefined ? options.numericDifferenceThreshold : DEFAULT_NUMERIC_DIFFERENCE;
+  const borderDifference = (options === null || options === void 0 ? void 0 : options.borderDifferenceThreshold) !== undefined ? options.borderDifferenceThreshold : DEFAULT_BORDER_DIFFERENCE;
   let tokenLogValue;
   let fallbackLogValue;
   let normalizedTokenValue = tokenValue;
@@ -26,15 +32,15 @@ export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
     }
     if (normalizedTokenValue && normalizedFallbackValue) {
       difference = compareHex(normalizedTokenValue, normalizedFallbackValue);
-      isAcceptableDifference = difference <= ACCEPTABLE_COLOR_DIFFERENCE;
+      isAcceptableDifference = difference <= colorDifference;
     }
-  } else if (lowerCaseTokenKey.startsWith('space')) {
+  } else if (lowerCaseTokenKey.startsWith('space') || lowerCaseTokenKey.startsWith('border')) {
     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;
+      isAcceptableDifference = difference <= (lowerCaseTokenKey.startsWith('space') ? spaceDifference : borderDifference);
     }
     // Log the normalized values
     normalizedTokenValue = tokenValue;
@@ -48,7 +54,7 @@ export function normalizeValues(tokenKey, tokenValue, fallbackValue) {
     if (!isNaN(tokenValueNumber) && !isNaN(fallbackValueNumber)) {
       const maxVal = Math.max(tokenValueNumber, fallbackValueNumber);
       difference = Math.abs(tokenValueNumber - fallbackValueNumber) / maxVal * 100;
-      isAcceptableDifference = difference <= ACCEPTABLE_NUMERIC_DIFFERENCE;
+      isAcceptableDifference = difference <= numericDifference;
     }
     // Log the normalized values
     normalizedTokenValue = tokenValue;

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

@@ -35,13 +35,13 @@ export function removeUnusedImports(importDeclarations, j) {
     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) {
+    var _importDeclaration$va, _importDeclaration$va2, _importDeclaration$va3, _importDeclaration$va4;
+    if (((_importDeclaration$va = importDeclaration.value) === null || _importDeclaration$va === void 0 ? void 0 : (_importDeclaration$va2 = _importDeclaration$va.specifiers) === null || _importDeclaration$va2 === void 0 ? void 0 : _importDeclaration$va2.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) {
+    if (((_importDeclaration$va3 = importDeclaration.value) === null || _importDeclaration$va3 === void 0 ? void 0 : (_importDeclaration$va4 = _importDeclaration$va3.specifiers) === null || _importDeclaration$va4 === void 0 ? void 0 : _importDeclaration$va4.length) === 0) {
       j(importDeclaration).remove();
       return true;
     }

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

@@ -25,6 +25,10 @@ function escapeCsvValue(value) {
 }
 export async function clearFolder(reportFolder) {
   console.log('Clearing report folder:', reportFolder);
+  // Create the folder if it doesn't exist
+  await fs.mkdir(reportFolder, {
+    recursive: true
+  });
   const filesToDelete = await fs.readdir(reportFolder);
   for (const file of filesToDelete) {
     const filePath = path.join(reportFolder, file);
@@ -33,7 +37,8 @@ export async function clearFolder(reportFolder) {
 }
 async function saveFilePaths(reportFolder, files) {
   const filesTxtPath = path.join(reportFolder, 'files.txt');
-  await fs.writeFile(filesTxtPath, Array.from(files).map(filePath => `"${filePath}"`).join(' '), 'utf-8');
+  const sortedFiles = Array.from(files).sort(); // Sort the file paths alphabetically
+  await fs.writeFile(filesTxtPath, sortedFiles.map(filePath => `"${filePath}"`).join('\n'), 'utf-8');
 }
 export async function combineReports(reportFolder) {
   console.log('Combining reports in folder:', reportFolder);

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

@@ -45,6 +45,29 @@ export class TokenProcessor {
   logError(message) {
     this.log(chalk.red(message));
   }
+
+  /**
+   * Checks if a token should be exempted from automatic fallback removal
+   * @param tokenKey The token key to check
+   * @returns An object containing whether the token should be exempted and related information
+   */
+  checkTokenExemption(tokenKey) {
+    // Create exemption list from user-provided skipTokens, and always include 'border'
+    const userExemptions = this.options.skipTokens ? this.options.skipTokens.split(',').map(item => item.trim()) : [];
+
+    // Always include 'border' in the exemption list
+    const exemptionList = [...userExemptions];
+    if (!exemptionList.includes('border')) {
+      exemptionList.push('border');
+    }
+    const isExemptedToken = exemptionList.some(prefix => tokenKey.startsWith(prefix));
+    const exemptedPrefix = isExemptedToken ? exemptionList.find(prefix => tokenKey.startsWith(prefix)) || null : null;
+    return {
+      shouldBeExempted: isExemptedToken,
+      exemptedPrefix,
+      exemptionList
+    };
+  }
   async processSingleToken(callPath) {
     var _callPath$node$loc2;
     const args = callPath.node.arguments;
@@ -67,20 +90,14 @@ export class TokenProcessor {
         resolvedLocalVarDeclaration: undefined
       };
     }
-    const isSkipped = tokenKey.startsWith('elevation.shadow') || tokenKey.startsWith('font.body') || tokenKey.startsWith('font.heading');
-    const tokenValue = isSkipped ? '' : this.tokenMap[tokenKey];
+    const tokenValue = this.tokenMap[tokenKey];
     this.logVerbose(`Token value from tokenMap: ${chalk.magenta(tokenValue)} for key: ${chalk.yellow(tokenKey)}`);
     const {
       rawFallbackValue,
       fallbackValue,
       resolvedImportDeclaration,
       resolvedLocalVarDeclaration
-    } = isSkipped ? {
-      rawFallbackValue: 'N/A',
-      fallbackValue: undefined,
-      resolvedImportDeclaration: undefined,
-      resolvedLocalVarDeclaration: undefined
-    } : await this.getFallbackValue(args[1]);
+    } = await this.getFallbackValue(args[1]);
     const {
       difference,
       isAcceptableDifference,
@@ -88,7 +105,7 @@ export class TokenProcessor {
       fallbackLogValue,
       normalizedTokenValue,
       normalizedFallbackValue
-    } = normalizeValues(tokenKey, tokenValue, fallbackValue);
+    } = normalizeValues(tokenKey, tokenValue, fallbackValue, this.options);
     const areEqual = normalizedTokenValue === normalizedFallbackValue;
     const logData = {
       teamInfo: this.teamInfo,
@@ -103,7 +120,22 @@ export class TokenProcessor {
     let fallbackRemoved = false;
     let importDeclaration;
     let localVarDeclaration;
-    if (areEqual || isAcceptableDifference || this.options.forceUpdate) {
+
+    // Check if token should be exempted
+    const {
+      shouldBeExempted,
+      exemptedPrefix
+    } = this.checkTokenExemption(tokenKey);
+
+    // Determine if we should modify this token based on the exemption status and settings
+    const shouldModifyToken =
+    // Always modify if not exempted and values match
+    areEqual && !shouldBeExempted ||
+    // Or if values don't exactly match but are acceptable to modify and not exempted
+    (isAcceptableDifference || this.options.forceUpdate) && !shouldBeExempted ||
+    // Or if exempted but values match exactly and we're not preserving skipped fallbacks
+    areEqual && shouldBeExempted && !this.options.preserveSkippedFallbacks;
+    if (shouldModifyToken) {
       this.log(chalk.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);
@@ -111,7 +143,7 @@ export class TokenProcessor {
       importDeclaration = resolvedImportDeclaration;
       localVarDeclaration = resolvedLocalVarDeclaration;
     } else {
-      const message = normalizedFallbackValue === undefined ? `Fallback value could not be resolved` : `Values mismatched significantly`;
+      const message = shouldBeExempted ? this.options.preserveSkippedFallbacks && areEqual ? `Preserving fallback for exempted token '${tokenKey}' (matches exemption '${exemptedPrefix}')` : `Skip modifying exempted token '${tokenKey}' (matches exemption '${exemptedPrefix}')` : normalizedFallbackValue === undefined ? `Fallback value could not be resolved` : `Values mismatched significantly`;
       this.logError(message);
       if (this.options.addEslintComments) {
         addOrUpdateEslintIgnoreComment(this.j, tokenValue, fallbackValue, callPath);
@@ -211,6 +243,56 @@ export class TokenProcessor {
     let objectName;
     let propertyName;
     let fallbackValue;
+    let resolvedImportDeclaration;
+    let resolvedLocalVarDeclaration;
+
+    // Function to get full member expression path as string
+    const getFullMemberPath = node => {
+      if (node.type === 'Identifier') {
+        return node.name;
+      } else if (node.type === 'MemberExpression') {
+        return `${getFullMemberPath(node.object)}.${node.property.type === 'Identifier' ? node.property.name : ''}`;
+      }
+      return '';
+    };
+    const fullMemberPath = getFullMemberPath(fallbackValueNode);
+
+    // Detect long member expression paths
+    const pathSegments = fullMemberPath.split('.');
+    if (pathSegments.length > 2) {
+      this.logVerbose(`Detected long member expression: ${chalk.yellow(fullMemberPath)}. Just resolving import or local variable declaration.`);
+
+      // Find the import statement or local variable for the top-level object
+      objectName = pathSegments[0];
+
+      // Check if it's a local variable
+      const localVarDeclaration = this.source.find(this.j.VariableDeclarator, {
+        id: {
+          name: objectName
+        }
+      }).at(0);
+      if (localVarDeclaration.size()) {
+        resolvedLocalVarDeclaration = localVarDeclaration.paths()[0];
+        this.logVerbose(`Resolved local variable declaration for: ${chalk.yellow(objectName)}`);
+      } else {
+        // Search for import declaration
+        const importDeclaration = this.source.find(this.j.ImportDeclaration).filter(this.createImportFilter(objectName)).at(0);
+        if (importDeclaration.size()) {
+          resolvedImportDeclaration = importDeclaration.paths()[0];
+          this.logVerbose(`Resolved import declaration for: ${chalk.yellow(objectName)}`);
+        } else {
+          this.logError(`Could not resolve import or local variable for: ${chalk.yellow(objectName)}`);
+        }
+      }
+      return {
+        rawFallbackValue: fullMemberPath,
+        fallbackValue: undefined,
+        resolvedImportDeclaration,
+        resolvedLocalVarDeclaration
+      };
+    }
+
+    // Existing logic for member expressions with shorter paths
     if (fallbackValueNode.object.type === 'Identifier') {
       objectName = fallbackValueNode.object.name;
     }
@@ -230,7 +312,6 @@ export class TokenProcessor {
     }
     const rawFallbackValue = `${objectName}.${propertyName}`;
     this.logVerbose(`Fallback is a member expression: ${chalk.yellow(rawFallbackValue)}, attempting to resolve...`);
-    let resolvedImportDeclaration;
 
     // Find the import statement for the object
     const importDeclaration = this.source.find(this.j.ImportDeclaration).filter(this.createImportFilter(objectName)).at(0);
@@ -253,22 +334,45 @@ export class TokenProcessor {
   }
   async processFallbackAsTemplateLiteral(fallbackValueNode) {
     const expressions = fallbackValueNode.expressions;
+    const quasis = fallbackValueNode.quasis;
+    let resolvedImportDeclaration;
+    let resolvedLocalVarDeclaration;
     let rawFallbackValue = '';
     let fallbackValue;
-    const quasis = fallbackValueNode.quasis;
     if (expressions.length !== 1 || quasis.length !== 2) {
       this.logError(`Unsupported template literal structure`);
+
+      // Attempt to resolve any imports or local variables used in expressions
+      for (const expression of expressions) {
+        if (expression.type === 'Identifier') {
+          const result = await this.processFallbackAsIdentifier(expression);
+          if (result.resolvedImportDeclaration) {
+            resolvedImportDeclaration = result.resolvedImportDeclaration;
+          }
+          if (result.resolvedLocalVarDeclaration) {
+            resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
+          }
+        } else if (expression.type === 'MemberExpression') {
+          const result = await this.processFallbackAsMemberExpression(expression);
+          if (result.resolvedImportDeclaration) {
+            resolvedImportDeclaration = result.resolvedImportDeclaration;
+          }
+          if (result.resolvedLocalVarDeclaration) {
+            resolvedLocalVarDeclaration = result.resolvedLocalVarDeclaration;
+          }
+        }
+      }
       return {
         rawFallbackValue,
         fallbackValue,
-        resolvedImportDeclaration: undefined,
-        resolvedLocalVarDeclaration: undefined
+        resolvedImportDeclaration,
+        resolvedLocalVarDeclaration
       };
     }
+
+    // Handle supported template literal structures as before
     let exprValue;
     const expression = expressions[0];
-    let resolvedImportDeclaration;
-    let resolvedLocalVarDeclaration;
     if (expression.type === 'Identifier') {
       const result = await this.processFallbackAsIdentifier(expression);
       exprValue = result.fallbackValue;

package/dist/esm/main.js

@@ -128,7 +128,7 @@ var resolveTransform = /*#__PURE__*/function () {
 }();
 var runTransform = /*#__PURE__*/function () {
   var _ref6 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(filePaths, transform, flags) {
-    var logger, codemodDirs, transformPath, args, jscodeshiftContent, jscodeshiftContentNew, transformModule;
+    var logger, codemodDirs, transformPath, ignorePatterns, ignoreArgs, args, jscodeshiftContent, jscodeshiftContentNew, transformModule;
     return _regeneratorRuntime.wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
@@ -153,15 +153,20 @@ var runTransform = /*#__PURE__*/function () {
           }
         case 9:
           logger.log(chalk.green("Transforming files matching these extensions '".concat(chalk.bold(flags.extensions), "'...")));
-          transformPath = getTransformPath(transform);
+          transformPath = getTransformPath(transform); // Split the ignorePattern by '|' and add each as a separate --ignore-pattern
+          ignorePatterns = flags.ignorePattern.split('|').filter(Boolean);
+          ignoreArgs = ignorePatterns.map(function (pattern) {
+            return "--ignore-pattern=".concat(pattern);
+          });
           args = Object.keys(flags).reduce(function (acc, key) {
             if (!['transform', 'parser', 'extensions', 'ignorePattern', 'logger', 'packages', 'sinceRef', 'preset', 'failOnError'].includes(key)) {
               acc.unshift("--".concat(key, "=").concat(flags[key]));
             }
             return acc;
-          }, ["--transform=".concat(transformPath), "--ignore-pattern=".concat(flags.ignorePattern), "--parser=".concat(flags.parser), "--extensions=".concat(flags.extensions),
+          }, ["--transform=".concat(transformPath)].concat(_toConsumableArray(ignoreArgs), [// Spread the ignoreArgs array here
+          "--parser=".concat(flags.parser), "--extensions=".concat(flags.extensions),
           // Limit CPUs to 8 to prevent issues when running on CI with a large amount of cpus
-          '--cpus=8'].concat(_toConsumableArray(codemodDirs)));
+          '--cpus=8'], _toConsumableArray(codemodDirs)));
           if (flags.failOnError) {
             args.unshift('--fail-on-error');
           }
@@ -179,24 +184,24 @@ var runTransform = /*#__PURE__*/function () {
             console.warn("Error loading transform module: ".concat(transformPath, ". Skipping lifecycle hooks."));
           }
           if (!transformModule) {
-            _context3.next = 20;
+            _context3.next = 22;
             break;
           }
-          _context3.next = 20;
-          return processLifecycleHook('beforeAll', transformModule, logger, transform, flags);
-        case 20:
           _context3.next = 22;
+          return processLifecycleHook('beforeAll', transformModule, logger, transform, flags);
+        case 22:
+          _context3.next = 24;
           return spawn(jscodeshift, args, {
             stdio: 'inherit'
           });
-        case 22:
+        case 24:
           if (!transformModule) {
-            _context3.next = 25;
+            _context3.next = 27;
             break;
           }
-          _context3.next = 25;
+          _context3.next = 27;
           return processLifecycleHook('afterAll', transformModule, logger, transform, flags);
-        case 25:
+        case 27:
         case "end":
           return _context3.stop();
       }
@@ -302,7 +307,7 @@ var defaultFlags = {
   ignorePattern: 'node_modules',
   logger: console
 };
-function processLifecycleHook(_x9, _x10, _x11, _x12, _x13) {
+function processLifecycleHook(_x9, _x0, _x1, _x10, _x11) {
   return _processLifecycleHook.apply(this, arguments);
 }
 function _processLifecycleHook() {
@@ -334,7 +339,7 @@ function _processLifecycleHook() {
   }));
   return _processLifecycleHook.apply(this, arguments);
 }
-export default function main(_x14, _x15) {
+export default function main(_x12, _x13) {
   return _main.apply(this, arguments);
 }
 function _main() {
@@ -350,7 +355,7 @@ function _main() {
         case 4:
           _yield$parseArgs = _context6.sent;
           packages = _yield$parseArgs.packages;
-          _process$env$_PACKAGE = "0.27.4", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+          _process$env$_PACKAGE = "0.28.1", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
           logger.log(chalk.bgBlue(chalk.black("\uD83D\uDCDA Atlassian-Frontend codemod library @ ".concat(_PACKAGE_VERSION_, " \uD83D\uDCDA"))));
           if (packages && packages.length > 0) {
             logger.log(chalk.gray("Searching for codemods for newer versions of the following packages: ".concat(packages.map(function (pkg) {