@atlaskit/codemod-utils 4.1.0 → 4.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @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

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);
         }
       }
 

package/dist/cjs/version.json

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

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);
         }
       }
 

package/dist/es2019/version.json

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

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);
         }
       }
 

package/dist/esm/version.json

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

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

@@ -16,6 +16,19 @@ 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/codemod-utils",
-  "version": "4.1.0",
+  "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 {};
+```