@atlaskit/codemod-utils 4.0.1 → 4.1.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaskit/codemod-utils
 
+## 4.1.1
+
+### Patch Changes
+
+- [`edc6fef0c8f`](https://bitbucket.org/atlassian/atlassian-frontend/commits/edc6fef0c8f) - Fix printf format specifier matching within `matchesStringWithFormatSpecifier` for fuzzy matching interpolated placeholder values
+
+## 4.1.0
+
+### Minor Changes
+
+- [`e4624adcb2f`](https://bitbucket.org/atlassian/atlassian-frontend/commits/e4624adcb2f) - ED-14608: Update codemod-utils to support type import entry point changes in changeImportEntryPoint, remove adf-utils from repo stricter lint exclusion lists
+
+## 4.0.2
+
+### Patch Changes
+
+- [`9358d42eeaa`](https://bitbucket.org/atlassian/atlassian-frontend/commits/9358d42eeaa) - NO-ISSUE: fixed codemod utils tryCreateImport() and addToImport() causing multiple insert in certain scenarios
+
 ## 4.0.1
 
 ### Patch Changes

package/dist/cjs/utils/index.js

@@ -275,7 +275,7 @@ var renameNamedImportWithAliasName = function renameNamedImportWithAliasName(com
 
 exports.renameNamedImportWithAliasName = renameNamedImportWithAliasName;
 
-var changeImportEntryPoint = function changeImportEntryPoint(oldPackageName, importToConvert, newPackageName) {
+var changeImportEntryPoint = function changeImportEntryPoint(oldPackageName, importToConvert, newPackageName, shouldBeTypeImport) {
   return function (j, root) {
     root.find(j.ImportDeclaration, {
       source: {
@@ -300,7 +300,7 @@ var changeImportEntryPoint = function changeImportEntryPoint(oldPackageName, imp
       var localSpecifierName = (_currentImportSpecifi = currentImportSpecifier.local) === null || _currentImportSpecifi === void 0 ? void 0 : _currentImportSpecifi.name;
       var newIdentifier = j.importSpecifier(j.identifier(importedSpecifierName), localSpecifierName ? j.identifier(localSpecifierName) : undefined); // check if new import exists, if not create it
 
-      (0, _support.tryCreateImport)(j, root, oldPackageName, newPackageName); // remove the old import specifier, but NOT the whole package
+      (0, _support.tryCreateImport)(j, root, oldPackageName, newPackageName, shouldBeTypeImport); // remove the old import specifier, but NOT the whole package
 
       root.find(j.ImportDeclaration, {
         source: {

package/dist/cjs/utils/support.js

@@ -14,6 +14,8 @@ exports.getJSXAttributesByName = exports.getDynamicImportName = exports.getDefau
 exports.getNamedSpecifier = getNamedSpecifier;
 exports.getSafeImportName = getSafeImportName;
 exports.isEmpty = exports.hasJSXAttributesByName = exports.hasImportDeclarationFromAnyPackageEntrypoint = exports.hasImportDeclaration = void 0;
+exports.matchesStringWithFormatSpecifier = matchesStringWithFormatSpecifier;
+exports.placeholderStringMatches = placeholderStringMatches;
 exports.removeImport = removeImport;
 exports.testMethodVariantEach = exports.shiftDefaultImport = void 0;
 exports.tryCreateImport = tryCreateImport;
@@ -190,18 +192,58 @@ var debug = function debug(component) {
 
 exports.debug = debug;
 
-var checkForStringWithFormatSpecifier = function checkForStringWithFormatSpecifier(argValue, str) {
-  var value = String(argValue);
-  var formatSpecifierRegex = /%[a-z]/g;
+function placeholderStringMatches(placeholderStr, resolvedStr) {
+  if (placeholderStr === resolvedStr) {
+    return true;
+  }
+
+  var value = '';
+  var offset = 0;
+  var partsPlaceholder = placeholderStr.split(' ');
+  var partsResolved = resolvedStr.split(' ');
+  partsPlaceholder.forEach(function (p, i) {
+    // Placeholder
+    if (p.startsWith('%')) {
+      // Trim remaining words from current position to avoid premature matching from previous parts
+      var remainingWords = partsResolved.slice(i + offset);
+      var nextWordIndex = remainingWords.indexOf(partsPlaceholder[i + 1]);
+      var hasNextWord = nextWordIndex !== -1;
+
+      if (hasNextWord) {
+        offset += nextWordIndex - 1;
+      }
 
-  if (value && value.match(formatSpecifierRegex)) {
-    var formatSpecifierReplacedStr = value.replace(formatSpecifierRegex, '.*');
-    var regex = new RegExp(formatSpecifierReplacedStr);
-    return regex.test(str);
+      var insert = remainingWords.slice(0, hasNextWord ? nextWordIndex : undefined).join(' ');
+      value += "".concat(insert, " "); // Regular words
+    } else {
+      value += "".concat(p, " ");
+    }
+  });
+  return value.trimRight() === resolvedStr;
+}
+/**
+ * Check whether a value contains a Format Specifier (printf placeholder)
+ *
+ * @see https://jestjs.io/docs/api#testeachtablename-fn-timeout
+ * @see https://nodejs.org/api/util.html#utilformatformat-args
+ *
+ * @param argValue The string potentially containing a format specifier (e.g. 'Foo %s')
+ * @param str The string that has replaced a format specifier with a tangible value (e.g. 'Foo Bar`)
+ *
+ * @returns Boolean: True if the strings matched (after considering the placeholder), or false if not.
+ */
+
+
+function matchesStringWithFormatSpecifier(argValue, str) {
+  var 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 {
+    // No format specifier placeholder
     return false;
   }
-};
+}
 
 var checkForTemplateLiteralsWithPlaceholders = function checkForTemplateLiteralsWithPlaceholders(quasis, str) {
   var templateStrs = quasis.map(function (quasi) {
@@ -220,7 +262,7 @@ var callExpressionArgMatchesString = function callExpressionArgMatchesString(arg
           return true;
         } else {
           // Eg: 'should contain %s'
-          return checkForStringWithFormatSpecifier(arg.value, str);
+          return matchesStringWithFormatSpecifier(arg.value, str);
         }
       }
 
@@ -286,27 +328,56 @@ function removeImport(j, base, packageName) {
   }).remove();
 }
 
-function tryCreateImport(j, base, relativeToPackage, packageName) {
-  var exists = base.find(j.ImportDeclaration).filter(function (path) {
+function tryCreateImport(j, base, relativeToPackage, packageName, shouldBeTypeImport) {
+  var matches = base.find(j.ImportDeclaration).filter(function (path) {
     return path.value.source.value === packageName;
-  }).length > 0;
+  });
+  var exists = matches.length > 0;
 
   if (exists) {
+    if (shouldBeTypeImport) {
+      // if the matched import declarations are not type imports
+      // but should be, we update them accordingly
+      var isTypeImports = matches.every(function (path) {
+        return path.value.importKind === 'type';
+      });
+
+      if (!isTypeImports) {
+        matches.filter(function (path) {
+          return path.value.importKind !== 'type';
+        }).forEach(function (path) {
+          path.value.importKind = 'type';
+        });
+        return;
+      }
+    }
+
     return;
+  } // 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)
+
+
+  var importDeclarationArgs = [[], j.literal(packageName)];
+
+  if (shouldBeTypeImport) {
+    importDeclarationArgs.push('type');
   }
 
   base.find(j.ImportDeclaration).filter(function (path) {
     return path.value.source.value === relativeToPackage;
-  }).insertBefore(j.importDeclaration([], j.literal(packageName)));
+  }) // 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.apply(j, importDeclarationArgs));
 }
 
 function addToImport(j, base, importSpecifier, packageName) {
   base.find(j.ImportDeclaration).filter(function (path) {
     return path.value.source.value === packageName;
-  }).replaceWith(function (declaration) {
+  }).at(0).replaceWith(function (declaration) {
     return j.importDeclaration([].concat((0, _toConsumableArray2.default)((declaration.value.specifiers || []).filter(function (item) {
       return item.type === 'ImportSpecifier' && item.imported != null;
-    })), [importSpecifier]), j.literal(packageName));
+    })), [importSpecifier]), j.literal(packageName), declaration.value.importKind);
   });
 }
 

package/dist/cjs/version.json

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

package/dist/es2019/utils/index.js

@@ -200,7 +200,7 @@ const renameNamedImportWithAliasName = (component, from, to) => (j, source) => {
   });
 };
 
-const changeImportEntryPoint = (oldPackageName, importToConvert, newPackageName) => (j, root) => {
+const changeImportEntryPoint = (oldPackageName, importToConvert, newPackageName, shouldBeTypeImport) => (j, root) => {
   root.find(j.ImportDeclaration, {
     source: {
       value: oldPackageName
@@ -224,7 +224,7 @@ const changeImportEntryPoint = (oldPackageName, importToConvert, newPackageName)
     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
 
-    tryCreateImport(j, root, oldPackageName, newPackageName); // remove the old import specifier, but NOT the whole package
+    tryCreateImport(j, root, oldPackageName, newPackageName, shouldBeTypeImport); // remove the old import specifier, but NOT the whole package
 
     root.find(j.ImportDeclaration, {
       source: {

package/dist/es2019/utils/support.js

@@ -135,18 +135,57 @@ const debug = component => (j, source) => {
   });
 };
 
-const checkForStringWithFormatSpecifier = (argValue, str) => {
-  const value = String(argValue);
-  const formatSpecifierRegex = /%[a-z]/g;
-
-  if (value && value.match(formatSpecifierRegex)) {
-    const formatSpecifierReplacedStr = value.replace(formatSpecifierRegex, '.*');
-    let regex = new RegExp(formatSpecifierReplacedStr);
-    return regex.test(str);
+export function placeholderStringMatches(placeholderStr, resolvedStr) {
+  if (placeholderStr === resolvedStr) {
+    return true;
+  }
+
+  let value = '';
+  let offset = 0;
+  const partsPlaceholder = placeholderStr.split(' ');
+  const partsResolved = resolvedStr.split(' ');
+  partsPlaceholder.forEach((p, i) => {
+    // Placeholder
+    if (p.startsWith('%')) {
+      // Trim remaining words from current position to avoid premature matching from previous parts
+      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
+    } else {
+      value += `${p} `;
+    }
+  });
+  return value.trimRight() === resolvedStr;
+}
+/**
+ * Check whether a value contains a Format Specifier (printf placeholder)
+ *
+ * @see https://jestjs.io/docs/api#testeachtablename-fn-timeout
+ * @see https://nodejs.org/api/util.html#utilformatformat-args
+ *
+ * @param argValue The string potentially containing a format specifier (e.g. 'Foo %s')
+ * @param str The string that has replaced a format specifier with a tangible value (e.g. 'Foo Bar`)
+ *
+ * @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
+
+  if (value && value.match(/%(p|s|d|i|f|j|o|#)/g)) {
+    return placeholderStringMatches(value, str);
   } else {
+    // No format specifier placeholder
     return false;
   }
-};
+}
 
 const checkForTemplateLiteralsWithPlaceholders = (quasis, str) => {
   const templateStrs = quasis.map(quasi => quasi.value.raw.trim()).join('.*');
@@ -163,7 +202,7 @@ const callExpressionArgMatchesString = (arg, str) => {
           return true;
         } else {
           // Eg: 'should contain %s'
-          return checkForStringWithFormatSpecifier(arg.value, str);
+          return matchesStringWithFormatSpecifier(arg.value, str);
         }
       }
 
@@ -215,22 +254,47 @@ function removeImport(j, base, packageName) {
   base.find(j.ImportDeclaration).filter(path => path.node.source.value === packageName).remove();
 }
 
-function tryCreateImport(j, base, relativeToPackage, packageName) {
-  const exists = base.find(j.ImportDeclaration).filter(path => path.value.source.value === packageName).length > 0;
+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';
+        });
+        return;
+      }
+    }
+
     return;
+  } // 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).insertBefore(j.importDeclaration([], j.literal(packageName)));
+  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).replaceWith(declaration => {
+  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
     // 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.specifiers || []).filter(item => item.type === 'ImportSpecifier' && item.imported != null), importSpecifier], j.literal(packageName), declaration.value.importKind);
   });
 }
 

package/dist/es2019/version.json

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

package/dist/esm/utils/index.js

@@ -246,7 +246,7 @@ var renameNamedImportWithAliasName = function renameNamedImportWithAliasName(com
   };
 };
 
-var changeImportEntryPoint = function changeImportEntryPoint(oldPackageName, importToConvert, newPackageName) {
+var changeImportEntryPoint = function changeImportEntryPoint(oldPackageName, importToConvert, newPackageName, shouldBeTypeImport) {
   return function (j, root) {
     root.find(j.ImportDeclaration, {
       source: {
@@ -271,7 +271,7 @@ var changeImportEntryPoint = function changeImportEntryPoint(oldPackageName, imp
       var localSpecifierName = (_currentImportSpecifi = currentImportSpecifier.local) === null || _currentImportSpecifi === void 0 ? void 0 : _currentImportSpecifi.name;
       var newIdentifier = j.importSpecifier(j.identifier(importedSpecifierName), localSpecifierName ? j.identifier(localSpecifierName) : undefined); // check if new import exists, if not create it
 
-      tryCreateImport(j, root, oldPackageName, newPackageName); // remove the old import specifier, but NOT the whole package
+      tryCreateImport(j, root, oldPackageName, newPackageName, shouldBeTypeImport); // remove the old import specifier, but NOT the whole package
 
       root.find(j.ImportDeclaration, {
         source: {

package/dist/esm/utils/support.js

@@ -153,18 +153,57 @@ var debug = function debug(component) {
   };
 };
 
-var checkForStringWithFormatSpecifier = function checkForStringWithFormatSpecifier(argValue, str) {
-  var value = String(argValue);
-  var formatSpecifierRegex = /%[a-z]/g;
-
-  if (value && value.match(formatSpecifierRegex)) {
-    var formatSpecifierReplacedStr = value.replace(formatSpecifierRegex, '.*');
-    var regex = new RegExp(formatSpecifierReplacedStr);
-    return regex.test(str);
+export function placeholderStringMatches(placeholderStr, resolvedStr) {
+  if (placeholderStr === resolvedStr) {
+    return true;
+  }
+
+  var value = '';
+  var offset = 0;
+  var partsPlaceholder = placeholderStr.split(' ');
+  var partsResolved = resolvedStr.split(' ');
+  partsPlaceholder.forEach(function (p, i) {
+    // Placeholder
+    if (p.startsWith('%')) {
+      // Trim remaining words from current position to avoid premature matching from previous parts
+      var remainingWords = partsResolved.slice(i + offset);
+      var nextWordIndex = remainingWords.indexOf(partsPlaceholder[i + 1]);
+      var hasNextWord = nextWordIndex !== -1;
+
+      if (hasNextWord) {
+        offset += nextWordIndex - 1;
+      }
+
+      var insert = remainingWords.slice(0, hasNextWord ? nextWordIndex : undefined).join(' ');
+      value += "".concat(insert, " "); // Regular words
+    } else {
+      value += "".concat(p, " ");
+    }
+  });
+  return value.trimRight() === resolvedStr;
+}
+/**
+ * Check whether a value contains a Format Specifier (printf placeholder)
+ *
+ * @see https://jestjs.io/docs/api#testeachtablename-fn-timeout
+ * @see https://nodejs.org/api/util.html#utilformatformat-args
+ *
+ * @param argValue The string potentially containing a format specifier (e.g. 'Foo %s')
+ * @param str The string that has replaced a format specifier with a tangible value (e.g. 'Foo Bar`)
+ *
+ * @returns Boolean: True if the strings matched (after considering the placeholder), or false if not.
+ */
+
+export function matchesStringWithFormatSpecifier(argValue, str) {
+  var 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 {
+    // No format specifier placeholder
     return false;
   }
-};
+}
 
 var checkForTemplateLiteralsWithPlaceholders = function checkForTemplateLiteralsWithPlaceholders(quasis, str) {
   var templateStrs = quasis.map(function (quasi) {
@@ -183,7 +222,7 @@ var callExpressionArgMatchesString = function callExpressionArgMatchesString(arg
           return true;
         } else {
           // Eg: 'should contain %s'
-          return checkForStringWithFormatSpecifier(arg.value, str);
+          return matchesStringWithFormatSpecifier(arg.value, str);
         }
       }
 
@@ -241,27 +280,56 @@ function removeImport(j, base, packageName) {
   }).remove();
 }
 
-function tryCreateImport(j, base, relativeToPackage, packageName) {
-  var exists = base.find(j.ImportDeclaration).filter(function (path) {
+function tryCreateImport(j, base, relativeToPackage, packageName, shouldBeTypeImport) {
+  var matches = base.find(j.ImportDeclaration).filter(function (path) {
     return path.value.source.value === packageName;
-  }).length > 0;
+  });
+  var exists = matches.length > 0;
 
   if (exists) {
+    if (shouldBeTypeImport) {
+      // if the matched import declarations are not type imports
+      // but should be, we update them accordingly
+      var isTypeImports = matches.every(function (path) {
+        return path.value.importKind === 'type';
+      });
+
+      if (!isTypeImports) {
+        matches.filter(function (path) {
+          return path.value.importKind !== 'type';
+        }).forEach(function (path) {
+          path.value.importKind = 'type';
+        });
+        return;
+      }
+    }
+
     return;
+  } // 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)
+
+
+  var importDeclarationArgs = [[], j.literal(packageName)];
+
+  if (shouldBeTypeImport) {
+    importDeclarationArgs.push('type');
   }
 
   base.find(j.ImportDeclaration).filter(function (path) {
     return path.value.source.value === relativeToPackage;
-  }).insertBefore(j.importDeclaration([], j.literal(packageName)));
+  }) // 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.apply(j, importDeclarationArgs));
 }
 
 function addToImport(j, base, importSpecifier, packageName) {
   base.find(j.ImportDeclaration).filter(function (path) {
     return path.value.source.value === packageName;
-  }).replaceWith(function (declaration) {
+  }).at(0).replaceWith(function (declaration) {
     return j.importDeclaration([].concat(_toConsumableArray((declaration.value.specifiers || []).filter(function (item) {
       return item.type === 'ImportSpecifier' && item.imported != null;
-    })), [importSpecifier]), j.literal(packageName));
+    })), [importSpecifier]), j.literal(packageName), declaration.value.importKind);
   });
 }
 

package/dist/esm/version.json

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

package/dist/types/utils/index.d.ts

@@ -11,5 +11,5 @@ declare const flattenCertainChildPropsAsProp: (component: string, propName: stri
 declare const createRenameJSXFunc: (packagePath: string, from: string, to: string, fallback?: string | undefined) => (j: core.JSCodeshift, source: any) => void;
 declare const createRemoveFuncAddCommentFor: (component: string, prop: string, comment?: string | undefined) => (j: core.JSCodeshift, source: Collection<Node>) => void;
 declare const renameNamedImportWithAliasName: (component: string, from: string, to: string) => (j: core.JSCodeshift, source: Collection<Node>) => void;
-declare const changeImportEntryPoint: (oldPackageName: string, importToConvert: string, newPackageName: string) => (j: core.JSCodeshift, root: Collection<Node>) => void;
+declare const changeImportEntryPoint: (oldPackageName: string, importToConvert: string, newPackageName: string, shouldBeTypeImport?: boolean | undefined) => (j: core.JSCodeshift, root: Collection<Node>) => void;
 export { createRenameFuncFor, createConvertFuncFor, createRenameImportFor, createRemoveFuncFor, replaceImportStatementFor, elevateComponentToNewEntryPoint, createTransformer, renameNamedImportWithAliasName, flattenCertainChildPropsAsProp, createRenameJSXFunc, createRemoveFuncAddCommentFor, changeImportEntryPoint, };

package/dist/types/utils/support.d.ts

@@ -16,12 +16,25 @@ declare const isEmpty: any;
 declare const hasImportDeclaration: (j: core.JSCodeshift, source: Collection<Node>, importPath: string) => boolean;
 declare const hasImportDeclarationFromAnyPackageEntrypoint: (j: core.JSCodeshift, source: Collection<Node>, packageName: string) => boolean;
 declare const debug: (component: string) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+export declare function placeholderStringMatches(placeholderStr: string, resolvedStr: string): boolean;
+/**
+ * Check whether a value contains a Format Specifier (printf placeholder)
+ *
+ * @see https://jestjs.io/docs/api#testeachtablename-fn-timeout
+ * @see https://nodejs.org/api/util.html#utilformatformat-args
+ *
+ * @param argValue The string potentially containing a format specifier (e.g. 'Foo %s')
+ * @param str The string that has replaced a format specifier with a tangible value (e.g. 'Foo Bar`)
+ *
+ * @returns Boolean: True if the strings matched (after considering the placeholder), or false if not.
+ */
+export declare function matchesStringWithFormatSpecifier(argValue: string | number | boolean | RegExp | null, str: string): boolean;
 declare const callExpressionArgMatchesString: (arg: CallExpression['arguments'][number], str: string) => boolean;
 declare const testMethodVariantEach: (path: ASTPath<CallExpression>, testMethods: Set<string>) => boolean;
 declare const hasJSXAttributesByName: (j: core.JSCodeshift, element: ASTPath<any>, attributeName: string) => boolean;
 declare const doesIdentifierExist: (j: core.JSCodeshift, base: Collection<any>, name: string) => boolean;
 declare function removeImport(j: core.JSCodeshift, base: Collection<any>, packageName: string): void;
-declare function tryCreateImport(j: core.JSCodeshift, base: Collection<any>, relativeToPackage: string, packageName: string): void;
+declare function tryCreateImport(j: core.JSCodeshift, base: Collection<any>, relativeToPackage: string, packageName: string, shouldBeTypeImport?: boolean): void;
 declare function addToImport(j: core.JSCodeshift, base: Collection<any>, importSpecifier: ImportSpecifier | ImportDefaultSpecifier, packageName: string): void;
 declare const shiftDefaultImport: (j: core.JSCodeshift, base: Collection<any>, defaultName: string, oldPackagePath: string, newPackagePath: string) => void;
 declare function getSafeImportName({ j, base, currentDefaultSpecifierName, desiredName, fallbackName, }: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/codemod-utils",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "author": "Atlassian Pty Ltd",
   "license": "Apache-2.0",
   "description": " jscodeshift-compatible codemod utilities",

package/report.api.md

@@ -0,0 +1,225 @@
+## API Report File for "@atlaskit/codemod-utils"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+import { API } from 'jscodeshift';
+import { ASTPath } from 'jscodeshift';
+import { CallExpression } from 'jscodeshift';
+import { Collection } from 'jscodeshift/src/Collection';
+import core from 'jscodeshift';
+import { FileInfo } from 'jscodeshift';
+import { ImportDeclaration } from 'jscodeshift';
+import { ImportDefaultSpecifier } from 'jscodeshift';
+import { ImportSpecifier } from 'jscodeshift';
+import { JSXAttribute } from 'jscodeshift';
+import { JSXElement } from 'jscodeshift';
+import { Options } from 'jscodeshift';
+import { Program } from 'jscodeshift';
+import { VariableDeclaration } from 'jscodeshift';
+import { VariableDeclarator } from 'jscodeshift';
+
+export declare function addCommentBefore(
+  j: core.JSCodeshift,
+  target:
+    | Collection<Program>
+    | Collection<ImportDeclaration>
+    | Collection<JSXElement>
+    | Collection<JSXAttribute>
+    | Collection<CallExpression>
+    | Collection<VariableDeclarator>,
+  message: string,
+  commentType?: 'block' | 'line',
+  messagePrefix?: string,
+): void;
+
+export declare const addCommentToStartOfFile: ({
+  j,
+  base,
+  message,
+}: {
+  j: core.JSCodeshift;
+  base: Collection<Node>;
+  message: string;
+}) => void;
+
+export declare const addDynamicImport: (
+  j: core.JSCodeshift,
+  target: Collection<VariableDeclaration>,
+  name: string,
+  packageEndpoint: string,
+) => void;
+
+export declare function addToImport(
+  j: core.JSCodeshift,
+  base: Collection<any>,
+  importSpecifier: ImportSpecifier | ImportDefaultSpecifier,
+  packageName: string,
+): void;
+
+export declare const callExpressionArgMatchesString: (
+  arg: CallExpression['arguments'][number],
+  str: string,
+) => boolean;
+
+export declare const changeImportEntryPoint: (
+  oldPackageName: string,
+  importToConvert: string,
+  newPackageName: string,
+  shouldBeTypeImport?: boolean | undefined,
+) => (j: core.JSCodeshift, root: Collection<Node>) => void;
+
+export declare const createConvertFuncFor: (
+  component: string,
+  from: string,
+  to: string,
+  predicate?: ((value: any) => boolean) | undefined,
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const createRemoveFuncAddCommentFor: (
+  component: string,
+  prop: string,
+  comment?: string | undefined,
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const createRemoveFuncFor: (
+  component: string,
+  importName: string,
+  prop: string,
+  predicate?: (j: core.JSCodeshift, element: ASTPath<any>) => boolean,
+  comment?: string | undefined,
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const createRenameFuncFor: (
+  component: string,
+  from: string,
+  to: string,
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const createRenameImportFor: (
+  component: string,
+  from: string,
+  to: string,
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const createRenameJSXFunc: (
+  packagePath: string,
+  from: string,
+  to: string,
+  fallback?: string | undefined,
+) => (j: core.JSCodeshift, source: any) => void;
+
+export declare const createTransformer: (
+  migrates: ((j: core.JSCodeshift, source: Collection<Node>) => void)[],
+  shouldApplyTransform?:
+    | ((j: core.JSCodeshift, source: Collection<Node>) => boolean)
+    | undefined,
+) => (fileInfo: FileInfo, { jscodeshift: j }: API, options: Options) => string;
+
+export declare const doesIdentifierExist: (
+  j: core.JSCodeshift,
+  base: Collection<any>,
+  name: string,
+) => boolean;
+
+export declare const elevateComponentToNewEntryPoint: (
+  pkg: string,
+  toPkg: string,
+  innerElementName: string,
+) => (j: core.JSCodeshift, root: any) => void;
+
+export declare const flattenCertainChildPropsAsProp: (
+  component: string,
+  propName: string,
+  childProps: string[],
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const getDefaultSpecifier: (
+  j: core.JSCodeshift,
+  source: Collection<Node>,
+  specifier: string,
+) => string | null;
+
+export declare const getDynamicImportName: (
+  j: core.JSCodeshift,
+  source: Collection<any>,
+  importPath: string,
+) => string | null;
+
+export declare const getJSXAttributesByName: (
+  j: core.JSCodeshift,
+  element: ASTPath<any>,
+  attributeName: string,
+) => Collection<JSXAttribute>;
+
+export declare function getNamedSpecifier(
+  j: core.JSCodeshift,
+  source: Collection<Node>,
+  specifier: string,
+  importName: string,
+): string | null;
+
+export declare function getSafeImportName({
+  j,
+  base,
+  currentDefaultSpecifierName,
+  desiredName,
+  fallbackName,
+}: {
+  j: core.JSCodeshift;
+  base: Collection<any>;
+  currentDefaultSpecifierName: string | null;
+  desiredName: string;
+  fallbackName: string;
+}): string;
+
+export declare const hasImportDeclaration: (
+  j: core.JSCodeshift,
+  source: Collection<Node>,
+  importPath: string,
+) => boolean;
+
+export declare const hasImportDeclarationFromAnyPackageEntrypoint: (
+  j: core.JSCodeshift,
+  source: Collection<Node>,
+  packageName: string,
+) => boolean;
+
+export declare const hasJSXAttributesByName: (
+  j: core.JSCodeshift,
+  element: ASTPath<any>,
+  attributeName: string,
+) => boolean;
+
+export declare function removeImport(
+  j: core.JSCodeshift,
+  base: Collection<any>,
+  packageName: string,
+): void;
+
+export declare const renameNamedImportWithAliasName: (
+  component: string,
+  from: string,
+  to: string,
+) => (j: core.JSCodeshift, source: Collection<Node>) => void;
+
+export declare const replaceImportStatementFor: (
+  pkg: string,
+  convertMap: any,
+) => (j: core.JSCodeshift, root: Collection<Node>) => void;
+
+export declare const testMethodVariantEach: (
+  path: ASTPath<CallExpression>,
+  testMethods: Set<string>,
+) => boolean;
+
+export declare function tryCreateImport(
+  j: core.JSCodeshift,
+  base: Collection<any>,
+  relativeToPackage: string,
+  packageName: string,
+  shouldBeTypeImport?: boolean,
+): void;
+
+export {};
+```