@atlaskit/codemod-utils 4.1.2 → 4.2.0

package/dist/es2019/utils/index.js

@@ -1,12 +1,9 @@
 import { addCommentToStartOfFile, addToImport, getDefaultSpecifier, getJSXAttributesByName, getNamedSpecifier, getSafeImportName, tryCreateImport } from './support';
-
 const createRemoveFuncFor = (component, importName, prop, predicate = () => true, comment) => (j, source) => {
   const specifier = getNamedSpecifier(j, source, component, importName);
-
   if (!specifier) {
     return;
   }
-
   source.findJSXElements(specifier).forEach(element => {
     if (predicate(j, element) && comment) {
       addCommentToStartOfFile({
@@ -21,40 +18,32 @@ const createRemoveFuncFor = (component, importName, prop, predicate = () => true
     }
   });
 };
-
 const createRenameFuncFor = (component, from, to) => (j, source) => {
   const defaultSpecifier = getDefaultSpecifier(j, source, component);
-
   if (!defaultSpecifier) {
     return;
   }
-
   source.findJSXElements(defaultSpecifier).forEach(element => {
     getJSXAttributesByName(j, element, from).forEach(attribute => {
       j(attribute).replaceWith(j.jsxAttribute(j.jsxIdentifier(to), attribute.node.value));
     });
   });
 };
-
 const createConvertFuncFor = (component, from, to, predicate) => (j, source) => {
   const defaultSpecifier = getDefaultSpecifier(j, source, component);
-
   if (!defaultSpecifier) {
     return;
   }
-
   source.findJSXElements(defaultSpecifier).forEach(element => {
     getJSXAttributesByName(j, element, from).forEach(attribute => {
       const shouldConvert = predicate && predicate(attribute.node.value) || false;
       const node = j.jsxAttribute(j.jsxIdentifier(to));
-
       if (shouldConvert) {
         j(attribute).insertBefore(node);
       }
     });
   });
 };
-
 const replaceImportStatementFor = (pkg, convertMap) => (j, root) => {
   root.find(j.ImportDeclaration).filter(path => path.node.source.value === pkg).forEach(path => {
     const defaultSpecifier = (path.value.specifiers || []).filter(specifier => specifier.type === 'ImportDefaultSpecifier');
@@ -65,7 +54,6 @@ const replaceImportStatementFor = (pkg, convertMap) => (j, root) => {
     j(path).replaceWith(defaultDeclarations);
     const otherDeclarations = otherSpecifier.map(s => {
       const localName = s.local.name;
-
       if (convertMap[localName]) {
         return j.importDeclaration([j.importDefaultSpecifier(j.identifier(localName))], j.literal(convertMap[localName]));
       } else {
@@ -75,26 +63,23 @@ const replaceImportStatementFor = (pkg, convertMap) => (j, root) => {
     j(path).insertAfter(otherDeclarations);
   });
 };
-
 const createRenameImportFor = (component, from, to) => (j, source) => {
   source.find(j.ImportDeclaration).filter(path => path.node.source.value === component).forEach(path => {
     j(path).replaceWith(j.importDeclaration(path.value.specifiers, j.literal(to)));
   });
 };
-
 const createTransformer = (migrates, shouldApplyTransform) => (fileInfo, {
   jscodeshift: j
 }, options) => {
-  const source = j(fileInfo.source); // If shouldApplyTransform not provided then perform old behaviour
+  const source = j(fileInfo.source);
 
+  // If shouldApplyTransform not provided then perform old behaviour
   if (!shouldApplyTransform || shouldApplyTransform(j, source)) {
     migrates.forEach(tf => tf(j, source));
     return source.toSource(options.printOptions);
   }
-
   return fileInfo.source;
 };
-
 const elevateComponentToNewEntryPoint = (pkg, toPkg, innerElementName) => (j, root) => {
   const importDeclarations = root.find(j.ImportDeclaration).filter(path => path.node.source.value === pkg);
   const defaultSpecifier = importDeclarations.find(j.ImportDefaultSpecifier).nodes();
@@ -114,14 +99,11 @@ const elevateComponentToNewEntryPoint = (pkg, toPkg, innerElementName) => (j, ro
     j(path).insertBefore(newOtherSpecifiers);
   });
 };
-
 const flattenCertainChildPropsAsProp = (component, propName, childProps) => (j, source) => {
   const defaultSpecifier = getDefaultSpecifier(j, source, component);
-
   if (!defaultSpecifier) {
     return;
   }
-
   source.findJSXElements(defaultSpecifier).forEach(element => {
     getJSXAttributesByName(j, element, propName).forEach(attribute => {
       j(attribute).find(j.JSXExpressionContainer).find(j.ObjectExpression).forEach(objectExpression => {
@@ -129,7 +111,6 @@ const flattenCertainChildPropsAsProp = (component, propName, childProps) => (j,
           childProps.forEach(childProp => {
             if ((property.type === 'Property' || property.type === 'ObjectProperty') && property.key.type === 'Identifier' && property.key.name === childProp) {
               var _element$node$opening;
-
               (_element$node$opening = element.node.openingElement.attributes) === null || _element$node$opening === void 0 ? void 0 : _element$node$opening.push(j.jsxAttribute(j.jsxIdentifier(childProp), j.jsxExpressionContainer(property.value)));
             }
           });
@@ -138,7 +119,6 @@ const flattenCertainChildPropsAsProp = (component, propName, childProps) => (j,
     });
   });
 };
-
 const createRenameJSXFunc = (packagePath, from, to, fallback = undefined) => (j, source) => {
   const namedSpecifier = getNamedSpecifier(j, source, packagePath, from);
   const toName = fallback ? getSafeImportName({
@@ -151,37 +131,29 @@ const createRenameJSXFunc = (packagePath, from, to, fallback = undefined) => (j,
   const existingAlias = source.find(j.ImportDeclaration).filter(path => path.node.source.value === packagePath).find(j.ImportSpecifier).nodes().map(specifier => {
     if (from !== specifier.imported.name) {
       return null;
-    } // If aliased: return the alias
-
-
+    }
+    // If aliased: return the alias
     if (specifier.local && from !== specifier.local.name) {
       return specifier.local.name;
     }
-
     return null;
   }).filter(Boolean)[0] || null;
   source.find(j.ImportDeclaration).filter(path => path.node.source.value === packagePath).find(j.ImportSpecifier).filter(importSpecifier => {
     const identifier = j(importSpecifier).find(j.Identifier).get();
-
     if (from === identifier.value.name || existingAlias === identifier.value.name) {
       return true;
     }
-
     return false;
   }).replaceWith([j.importSpecifier(j.identifier(toName), existingAlias ? j.identifier(existingAlias) : null)], j.literal(packagePath));
 };
-
 const createRemoveFuncAddCommentFor = (component, prop, comment) => (j, source) => {
   const defaultSpecifier = getDefaultSpecifier(j, source, component);
-
   if (!defaultSpecifier) {
     return;
   }
-
   source.findJSXElements(defaultSpecifier).forEach(element => {
     getJSXAttributesByName(j, element, prop).forEach(attribute => {
       j(attribute).remove();
-
       if (comment) {
         addCommentToStartOfFile({
           j,
@@ -192,14 +164,12 @@ const createRemoveFuncAddCommentFor = (component, prop, comment) => (j, source)
     });
   });
 };
-
 const renameNamedImportWithAliasName = (component, from, to) => (j, source) => {
   source.find(j.ImportDeclaration).filter(path => path.node.source.value === component).find(j.ImportSpecifier).filter(path => path.node.imported.name === from).forEach(path => {
     const localName = path.node.local.name;
     j(path).replaceWith(j.importSpecifier(j.identifier(to), j.identifier(localName)));
   });
 };
-
 const changeImportEntryPoint = (oldPackageName, importToConvert, newPackageName, shouldBeTypeImport) => (j, root) => {
   root.find(j.ImportDeclaration, {
     source: {
@@ -207,43 +177,41 @@ const changeImportEntryPoint = (oldPackageName, importToConvert, newPackageName,
     }
   }).forEach(path => {
     var _currentImportSpecifi;
-
     const currentImportSpecifier = (path.value.specifiers || []).find(specifier => {
       if (specifier.type === 'ImportSpecifier') {
         return specifier.imported.name === importToConvert;
       }
-
       return false;
     });
-
     if (!currentImportSpecifier) {
       return;
     }
-
     const importedSpecifierName = currentImportSpecifier.imported.name;
     const localSpecifierName = (_currentImportSpecifi = currentImportSpecifier.local) === null || _currentImportSpecifi === void 0 ? void 0 : _currentImportSpecifi.name;
-    const newIdentifier = j.importSpecifier(j.identifier(importedSpecifierName), localSpecifierName ? j.identifier(localSpecifierName) : undefined); // check if new import exists, if not create it
+    const newIdentifier = j.importSpecifier(j.identifier(importedSpecifierName), localSpecifierName ? j.identifier(localSpecifierName) : undefined);
 
-    tryCreateImport(j, root, oldPackageName, newPackageName, shouldBeTypeImport); // remove the old import specifier, but NOT the whole package
+    // check if new import exists, if not create it
+    tryCreateImport(j, root, oldPackageName, newPackageName, shouldBeTypeImport);
 
+    // remove the old import specifier, but NOT the whole package
     root.find(j.ImportDeclaration, {
       source: {
         value: oldPackageName
       }
-    }).find(j.ImportSpecifier).filter(path => path.value.imported.name === importToConvert).remove(); // adds import specifier to new import
+    }).find(j.ImportSpecifier).filter(path => path.value.imported.name === importToConvert).remove();
 
-    addToImport(j, root, newIdentifier, newPackageName); // if there are any imports with no specifiers, remove the whole import
+    // adds import specifier to new import
+    addToImport(j, root, newIdentifier, newPackageName);
 
+    // if there are any imports with no specifiers, remove the whole import
     root.find(j.ImportDeclaration, {
       source: {
         value: oldPackageName
       }
     }).filter(path => {
       var _path$value$specifier;
-
       return !((_path$value$specifier = path.value.specifiers) !== null && _path$value$specifier !== void 0 && _path$value$specifier.length);
     }).remove();
   });
 };
-
 export { createRenameFuncFor, createConvertFuncFor, createRenameImportFor, createRemoveFuncFor, replaceImportStatementFor, elevateComponentToNewEntryPoint, createTransformer, renameNamedImportWithAliasName, flattenCertainChildPropsAsProp, createRenameJSXFunc, createRemoveFuncAddCommentFor, changeImportEntryPoint };

package/dist/es2019/utils/support.js

@@ -1,13 +1,10 @@
 function getNamedSpecifier(j, source, specifier, importName) {
   const specifiers = source.find(j.ImportDeclaration).filter(path => path.node.source.value === specifier).find(j.ImportSpecifier).filter(path => path.node.imported.name === importName);
-
   if (!specifiers.length) {
     return null;
   }
-
   return specifiers.nodes()[0].local.name;
 }
-
 const getDynamicImportName = (j, source, importPath) => {
   const dynamicImports = source.find(j.VariableDeclarator).filter(variableDeclaratorPath => {
     return j(variableDeclaratorPath).find(j.CallExpression).filter(callExpressionPath => {
@@ -18,48 +15,38 @@ const getDynamicImportName = (j, source, importPath) => {
       return !!(isCallExpressionCalleeImportType(callee) && isCallExpressionArgumentStringLiteralType(callExpressionArguments) && isCallExpressionArgumentValueMatches(callExpressionArguments[0], j, importPath));
     }).length > 0;
   });
-
   if (!dynamicImports.length) {
     return null;
   }
-
   const {
     id
   } = dynamicImports.nodes()[0];
-
   if (id.type !== 'Identifier') {
     return null;
   }
-
   return id.name;
 };
-
 const isCallExpressionCalleeImportType = callee => {
   return callee && callee.type === 'Import';
 };
-
 const isCallExpressionArgumentStringLiteralType = callExpressionArguments => {
   return callExpressionArguments && callExpressionArguments.length && callExpressionArguments[0].type === 'StringLiteral';
 };
-
 const isCallExpressionArgumentValueMatches = (callExpressionArgument, j, value) => {
   return j(callExpressionArgument).some(path => path.node.value === value);
 };
-
 const addDynamicImport = (j, target, name, packageEndpoint) => {
   const node = j.variableDeclaration('const', [j.variableDeclarator(j.identifier(name), j.callExpression(j.memberExpression(j.identifier('React'), j.identifier('lazy')), [j.arrowFunctionExpression([], j.callExpression(j.import(), [j.stringLiteral(packageEndpoint)]))]))]);
   target.insertAfter(node);
   addCommentBefore(j, j(node), 'We have added "React.lazy" here. Feel free to change it to "lazy" or other named import depending upon how you imported.');
-}; // not replacing newlines (which \s does)
-
+};
 
+// not replacing newlines (which \s does)
 const spacesAndTabs = /[ \t]{2,}/g;
 const lineStartWithSpaces = /^[ \t]*/gm;
-
 function clean(value) {
   return value.replace(spacesAndTabs, ' ').replace(lineStartWithSpaces, '').trim();
 }
-
 const addCommentToStartOfFile = ({
   j,
   base,
@@ -67,18 +54,17 @@ const addCommentToStartOfFile = ({
 }) => {
   addCommentBefore(j, base.find(j.Program), message);
 };
-
 function addCommentBefore(j, target, message, commentType = 'block', messagePrefix = 'TODO: (from codemod) ') {
   const msg = clean(messagePrefix + message);
   const content = commentType === 'block' ? ` ${msg} ` : ` ${msg}`;
   target.forEach(path => {
     path.value.comments = path.value.comments || [];
-    const exists = path.value.comments.find(comment => comment.value === content); // avoiding duplicates of the same comment
+    const exists = path.value.comments.find(comment => comment.value === content);
 
+    // avoiding duplicates of the same comment
     if (exists) {
       return;
     }
-
     if (commentType === 'block') {
       path.value.comments.push(j.commentBlock(content));
     } else {
@@ -86,50 +72,40 @@ function addCommentBefore(j, target, message, commentType = 'block', messagePref
     }
   });
 }
-
 const getDefaultSpecifier = (j, source, specifier) => {
   const specifiers = source.find(j.ImportDeclaration).filter(path => path.node.source.value === specifier).find(j.ImportDefaultSpecifier);
-
   if (!specifiers.length) {
     return null;
   }
-
   return specifiers.nodes()[0].local.name;
-}; // @ts-ignore
-
+};
 
+// @ts-ignore
 const getJSXAttributesByName = (j, element, attributeName) => {
   return j(element).find(j.JSXOpeningElement).at(0).find(j.JSXAttribute).filter(attribute => {
     const matches = j(attribute).find(j.JSXIdentifier).filter(identifier => identifier.value.name === attributeName);
     return Boolean(matches.length);
   });
 };
-
 const isEmpty = string => string && string.value !== '';
-
 const hasImportDeclaration = (j, source, importPath) => {
   const imports = source.find(j.ImportDeclaration).filter(path => path.node.source.value === importPath);
   return Boolean(imports.length);
 };
-
 const hasImportDeclarationFromAnyPackageEntrypoint = (j, source, packageName) => {
   const imports = source.find(j.ImportDeclaration).filter(path => {
     var _path$node, _path$node$source;
-
     return (// @ts-ignore
       path === null || path === void 0 ? void 0 : (_path$node = path.node) === null || _path$node === void 0 ? void 0 : (_path$node$source = _path$node.source) === null || _path$node$source === void 0 ? void 0 : _path$node$source.value.toString().startsWith(packageName)
     );
   });
   return Boolean(imports.length);
 };
-
 const debug = component => (j, source) => {
   const defaultSpecifier = getDefaultSpecifier(j, source, component);
-
   if (!defaultSpecifier) {
     return;
   }
-
   source.findJSXElements(defaultSpecifier).forEach(element => {
     console.log(element); //eslint-disable-line no-console
   });
@@ -139,7 +115,6 @@ export function placeholderStringMatches(placeholderStr, resolvedStr) {
   if (placeholderStr === resolvedStr) {
     return true;
   }
-
   let value = '';
   let offset = 0;
   const partsPlaceholder = placeholderStr.split(' ');
@@ -151,19 +126,19 @@ export function placeholderStringMatches(placeholderStr, resolvedStr) {
       const remainingWords = partsResolved.slice(i + offset);
       const nextWordIndex = remainingWords.indexOf(partsPlaceholder[i + 1]);
       const hasNextWord = nextWordIndex !== -1;
-
       if (hasNextWord) {
         offset += nextWordIndex - 1;
       }
-
       const insert = remainingWords.slice(0, hasNextWord ? nextWordIndex : undefined).join(' ');
-      value += `${insert} `; // Regular words
+      value += `${insert} `;
+      // Regular words
     } else {
       value += `${p} `;
     }
   });
   return value.trimRight() === resolvedStr;
 }
+
 /**
  * Check whether a value contains a Format Specifier (printf placeholder)
  *
@@ -175,10 +150,9 @@ export function placeholderStringMatches(placeholderStr, resolvedStr) {
  *
  * @returns Boolean: True if the strings matched (after considering the placeholder), or false if not.
  */
-
 export function matchesStringWithFormatSpecifier(argValue, str) {
-  const value = String(argValue); // Check whether value contains a printf format placeholder e.g. %s, %d etc
-
+  const value = String(argValue);
+  // Check whether value contains a printf format placeholder e.g. %s, %d etc
   if (value && value.match(/%(p|s|d|i|f|j|o|#)/g)) {
     return placeholderStringMatches(value, str);
   } else {
@@ -186,13 +160,11 @@ export function matchesStringWithFormatSpecifier(argValue, str) {
     return false;
   }
 }
-
 const checkForTemplateLiteralsWithPlaceholders = (quasis, str) => {
   const templateStrs = quasis.map(quasi => quasi.value.raw.trim()).join('.*');
   let regex = new RegExp(templateStrs);
   return regex.test(str);
 };
-
 const callExpressionArgMatchesString = (arg, str) => {
   switch (arg.type) {
     case 'StringLiteral':
@@ -205,14 +177,12 @@ const callExpressionArgMatchesString = (arg, str) => {
           return matchesStringWithFormatSpecifier(arg.value, str);
         }
       }
-
     case 'TemplateLiteral':
       {
         // fuzzy match template literals, skipping expressions
         const templateStrs = arg.quasis.map(quasi => {
           return quasi.value.raw.trim();
         }).join(' ');
-
         if (str.trim() === templateStrs.trim()) {
           return true;
         } else {
@@ -220,50 +190,43 @@ const callExpressionArgMatchesString = (arg, str) => {
           return checkForTemplateLiteralsWithPlaceholders(arg.quasis, str);
         }
       }
-
     case 'BinaryExpression':
       {
         return false;
       }
-
     default:
       {
         return false;
       }
   }
 };
-
 const testMethodVariantEach = (path, testMethods) => {
   var _path$value, _path$value$callee, _path$value$callee$ca, _path$value2, _path$value2$callee, _path$value2$callee$c, _path$value2$callee$c2, _path$value3, _path$value3$callee, _path$value3$callee$c, _path$value3$callee$c2;
-
   const variants = new Set(['each']);
-  return (// @ts-ignore
-    ((_path$value = path.value) === null || _path$value === void 0 ? void 0 : (_path$value$callee = _path$value.callee) === null || _path$value$callee === void 0 ? void 0 : (_path$value$callee$ca = _path$value$callee.callee) === null || _path$value$callee$ca === void 0 ? void 0 : _path$value$callee$ca.type) === 'MemberExpression' && // @ts-ignore
-    testMethods.has((_path$value2 = path.value) === null || _path$value2 === void 0 ? void 0 : (_path$value2$callee = _path$value2.callee) === null || _path$value2$callee === void 0 ? void 0 : (_path$value2$callee$c = _path$value2$callee.callee) === null || _path$value2$callee$c === void 0 ? void 0 : (_path$value2$callee$c2 = _path$value2$callee$c.object) === null || _path$value2$callee$c2 === void 0 ? void 0 : _path$value2$callee$c2.name) && // @ts-ignore
+  return (
+    // @ts-ignore
+    ((_path$value = path.value) === null || _path$value === void 0 ? void 0 : (_path$value$callee = _path$value.callee) === null || _path$value$callee === void 0 ? void 0 : (_path$value$callee$ca = _path$value$callee.callee) === null || _path$value$callee$ca === void 0 ? void 0 : _path$value$callee$ca.type) === 'MemberExpression' &&
+    // @ts-ignore
+    testMethods.has((_path$value2 = path.value) === null || _path$value2 === void 0 ? void 0 : (_path$value2$callee = _path$value2.callee) === null || _path$value2$callee === void 0 ? void 0 : (_path$value2$callee$c = _path$value2$callee.callee) === null || _path$value2$callee$c === void 0 ? void 0 : (_path$value2$callee$c2 = _path$value2$callee$c.object) === null || _path$value2$callee$c2 === void 0 ? void 0 : _path$value2$callee$c2.name) &&
+    // @ts-ignore
     variants.has((_path$value3 = path.value) === null || _path$value3 === void 0 ? void 0 : (_path$value3$callee = _path$value3.callee) === null || _path$value3$callee === void 0 ? void 0 : (_path$value3$callee$c = _path$value3$callee.callee) === null || _path$value3$callee$c === void 0 ? void 0 : (_path$value3$callee$c2 = _path$value3$callee$c.property) === null || _path$value3$callee$c2 === void 0 ? void 0 : _path$value3$callee$c2.name)
   );
 };
-
 const hasJSXAttributesByName = (j, element, attributeName) => getJSXAttributesByName(j, element, attributeName).length > 0;
-
 const doesIdentifierExist = (j, base, name) => {
   return base.find(j.Identifier).filter(identifer => identifer.value.name === name).length > 0;
 };
-
 function removeImport(j, base, packageName) {
   base.find(j.ImportDeclaration).filter(path => path.node.source.value === packageName).remove();
 }
-
 function tryCreateImport(j, base, relativeToPackage, packageName, shouldBeTypeImport) {
   const matches = base.find(j.ImportDeclaration).filter(path => path.value.source.value === packageName);
   const exists = matches.length > 0;
-
   if (exists) {
     if (shouldBeTypeImport) {
       // if the matched import declarations are not type imports
       // but should be, we update them accordingly
       const isTypeImports = matches.every(path => path.value.importKind === 'type');
-
       if (!isTypeImports) {
         matches.filter(path => path.value.importKind !== 'type').forEach(path => {
           path.value.importKind = 'type';
@@ -271,40 +234,37 @@ function tryCreateImport(j, base, relativeToPackage, packageName, shouldBeTypeIm
         return;
       }
     }
-
     return;
-  } // we dynamically build up importDeclaration args, so that if shouldBeTypeImport
+  }
+
+  // we dynamically build up importDeclaration args, so that if shouldBeTypeImport
   // is falsy, it is never passed explicitly as an importKind parameter (avoiding
   // runtime exceptions during transform runs when importKind is undefined)
-
-
   const importDeclarationArgs = [[], j.literal(packageName)];
-
   if (shouldBeTypeImport) {
     importDeclarationArgs.push('type');
   }
-
-  base.find(j.ImportDeclaration).filter(path => path.value.source.value === relativeToPackage) // we only take the first matching path, to avoid duplicate inserts
+  base.find(j.ImportDeclaration).filter(path => path.value.source.value === relativeToPackage)
+  // we only take the first matching path, to avoid duplicate inserts
   // if the source contains the same import declaration more than once
   .paths()[0].insertBefore(j.importDeclaration(...importDeclarationArgs));
 }
-
 function addToImport(j, base, importSpecifier, packageName) {
   base.find(j.ImportDeclaration).filter(path => path.value.source.value === packageName).at(0).replaceWith(declaration => {
-    return j.importDeclaration([// we are appending to the existing specifiers
+    return j.importDeclaration([
+    // we are appending to the existing specifiers
     // We are doing a filter hear because sometimes specifiers can be removed
     // but they hand around in the declaration
     ...(declaration.value.specifiers || []).filter(item => item.type === 'ImportSpecifier' && item.imported != null), importSpecifier], j.literal(packageName), declaration.value.importKind);
   });
 }
-
 const shiftDefaultImport = (j, base, defaultName, oldPackagePath, newPackagePath) => {
   tryCreateImport(j, base, oldPackagePath, newPackagePath);
-  addToImport(j, base, j.importDefaultSpecifier(j.identifier(defaultName)), newPackagePath); // removing old default specifier
+  addToImport(j, base, j.importDefaultSpecifier(j.identifier(defaultName)), newPackagePath);
 
+  // removing old default specifier
   base.find(j.ImportDeclaration).filter(path => path.node.source.value === oldPackagePath).remove();
 };
-
 function getSafeImportName({
   j,
   base,
@@ -315,9 +275,7 @@ function getSafeImportName({
   if (currentDefaultSpecifierName === desiredName) {
     return desiredName;
   }
-
   const isUsed = doesIdentifierExist(j, base, desiredName);
   return isUsed ? fallbackName : desiredName;
 }
-
 export { getDefaultSpecifier, getNamedSpecifier, getJSXAttributesByName, hasJSXAttributesByName, hasImportDeclaration, hasImportDeclarationFromAnyPackageEntrypoint, addCommentBefore, addCommentToStartOfFile, doesIdentifierExist, removeImport, tryCreateImport, addToImport, shiftDefaultImport, isEmpty, clean, debug, callExpressionArgMatchesString, testMethodVariantEach, getSafeImportName, getDynamicImportName, addDynamicImport };

package/dist/es2019/version.json

@@ -1,5 +1,5 @@
 {
 	"name": "@atlaskit/codemod-utils",
-	"version": "4.1.2",
+	"version": "4.2.0",
 	"sideEffects": false
 }