@atlaskit/codemod-cli 0.11.3 → 0.11.5

package/dist/es2019/presets/theme-to-design-tokens/theme-to-design-tokens.js

@@ -1,4 +1,5 @@
 /* eslint-disable no-console */
+
 import { isDecendantOfToken, isDecendantOfType } from './utils/ast';
 import { cleanMeta, getMetaFromAncestors } from './utils/ast-meta';
 import { includesHardCodedColor, isHardCodedColor, isLegacyColor, isLegacyNamedColor } from './utils/color';
@@ -6,11 +7,9 @@ import Search from './utils/fuzzy-search';
 import { legacyColorMetaMap } from './utils/legacy-colors';
 import { tokens } from './utils/tokens';
 const search = Search(tokens, false);
-
 function hasImportDeclaration(j, source, sourcePath) {
   return !!source.find(j.ImportDeclaration).filter(path => path.node.source.value === sourcePath).length;
 }
-
 function hasImportSpecifier(j, source, specifier, sourcePath) {
   return !!source.find(j.ImportDeclaration).filter(path => path.node.source.value === sourcePath).find(j.ImportSpecifier, {
     local: {
@@ -18,39 +17,33 @@ function hasImportSpecifier(j, source, specifier, sourcePath) {
     }
   }).length;
 }
-
 function insertTokenImport(j, source) {
   if (hasImportDeclaration(j, source, '@atlaskit/tokens')) {
     return;
   }
-
   const newImport = j.importDeclaration([j.importSpecifier(j.identifier('token'))], j.stringLiteral('@atlaskit/tokens'));
   source.get().node.program.body.unshift(newImport);
 }
-
 function buildToken(j, tokenId, node) {
   const callExpr = j.callExpression(j.identifier('token'), [j.stringLiteral(tokenId), node].filter(Boolean));
   return callExpr;
 }
-
 function getTokenFromNode(j, path, baseMeta = []) {
   const foundMeta = getMetaFromAncestors(j, path);
   const meta = cleanMeta([...foundMeta, ...baseMeta]);
   const results = search.get(meta.join(' '));
-  let tokenId = ['utility.UNSAFE_util.MISSING_TOKEN'];
-
+  let tokenId = ['MISSING_TOKEN'];
   if (results) {
     tokenId = results.map(result => result[1]);
   }
-
   return tokenId[0];
 }
-
 export default function transformer(file, api, debug = false) {
   const j = api.jscodeshift;
   const source = j(file.source);
   let transformed = false;
-  source // Handle colors.N100
+  source
+  // Handle colors.N100
   .find(j.MemberExpression).filter(path => {
     return path.value.object.type === 'Identifier' && path.value.object.name === 'colors' && path.value.property.type === 'Identifier' && isLegacyColor(path.value.property.name);
   }).filter(path => !isDecendantOfToken(j, path)).forEach(path => {
@@ -81,7 +74,6 @@ export default function transformer(file, api, debug = false) {
   });
   source.find(j.Literal).filter(path => typeof path.value.value === 'string' && (includesHardCodedColor(path.value.value) || isHardCodedColor(path.value.value))).filter(path => !isDecendantOfToken(j, path)).forEach(path => {
     var _path$value, _path$value$value;
-
     debug && console.log('file:', file.path);
     insertTokenImport(j, source);
     const value = path === null || path === void 0 ? void 0 : (_path$value = path.value) === null || _path$value === void 0 ? void 0 : (_path$value$value = _path$value.value) === null || _path$value$value === void 0 ? void 0 : _path$value$value.toString();
@@ -91,10 +83,8 @@ export default function transformer(file, api, debug = false) {
     j(path).replaceWith(isDecendantOfType(j, path, j.JSXAttribute) ? j.jsxExpressionContainer(tokenNode) : tokenNode);
     transformed = true;
   });
-
   if (transformed) {
     return source.toSource();
   }
-
   return file.source;
 }

package/dist/es2019/presets/theme-to-design-tokens/utils/ast-meta.js

@@ -2,27 +2,23 @@ import { getUniqueWordsFromTokens } from './tokens';
 export function getMetaFromAncestors(j, path, meta = []) {
   const parent = path.parentPath;
   const grandParent = parent && parent.parentPath;
-
   if (parent && parent.value.type === 'ObjectProperty') {
     let value = '';
-
     if (parent.value.key.type === 'Literal' || parent.value.key.type === 'StringLiteral' || parent.value.key.type === 'NumericLiteral') {
       value = parent.value.key.value.toString();
     } else {
       value = parent.value.key.name;
     }
-
     meta.push(value);
   }
-
   if (parent && grandParent && grandParent.value.type === 'TemplateLiteral') {
     const expressionIndex = grandParent.value.expressions.findIndex(exp => exp.name === path.value.name);
     const quasi = grandParent.value.quasis[expressionIndex];
     const propertyName = (quasi.value.cooked || quasi.value.raw || '').replace(/\n/g, '').split(/;|{|}/).filter(el => !el.match(/\.|\@|\(|\)/)).pop().split(/:/g)[0].trim();
-    grandParent.value.quasis.slice(0, expressionIndex + 1).map(q => q.value.cooked) // We reverse so the most nested one is first which we're more likely than not interested in
+    grandParent.value.quasis.slice(0, expressionIndex + 1).map(q => q.value.cooked)
+    // We reverse so the most nested one is first which we're more likely than not interested in
     .reverse().some(str => {
       const result = /(hover|active|disabled|focus)/.exec(str.toLowerCase());
-
       if (result) {
         meta.push(result[0]);
         return true;
@@ -30,21 +26,17 @@ export function getMetaFromAncestors(j, path, meta = []) {
     });
     meta.push(propertyName);
   }
-
   if (parent && parent.value.type === 'JSXAttribute') {
     if (!['css', 'styles', 'style'].includes(parent.value.name.name)) {
       meta.push(parent.value.name.name);
     }
   }
-
   if (parent && parent.value.type === 'VariableDeclarator') {
     meta.push(parent.value.id.name);
   }
-
   if (parent) {
     return getMetaFromAncestors(j, parent, meta);
   }
-
   return meta;
 }
 export function cleanMeta(meta) {
@@ -57,7 +49,6 @@ export function cleanMeta(meta) {
     if (!accum.includes(val)) {
       accum.push(val);
     }
-
     return accum;
   }, []);
 }

package/dist/es2019/presets/theme-to-design-tokens/utils/color.js

@@ -4,32 +4,27 @@ export const isLegacyColor = value => legacyColors.includes(value);
 export const isLegacyNamedColor = value => legacyColorMixins.includes(value);
 export const includesHardCodedColor = raw => {
   const value = raw.toLowerCase();
-
   if (/#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})\b|(?:rgb|hsl)a?\([^\)]*\)/.exec(value.toLowerCase())) {
     return true;
   }
-
   for (let i = 0; i < namedColors.length; i++) {
     if (value.includes(`${namedColors[i]};`)) {
       return true;
     }
   }
-
   return false;
 };
 export const isHardCodedColor = value => {
   if (namedColors.includes(value.toLowerCase())) {
     return true;
   }
-
   if (value.startsWith('rgb(') || value.startsWith('rgba(') || value.startsWith('hsl(') || value.startsWith('hsla(') || value.startsWith('lch(') || value.startsWith('lab(') || value.startsWith('color(')) {
     return true;
   }
-
-  if (value.startsWith('#') && ( // short hex, hex, or hex with alpha
+  if (value.startsWith('#') && (
+  // short hex, hex, or hex with alpha
   value.length === 4 || value.length === 7 || value.length === 9)) {
     return true;
   }
-
   return false;
 };

package/dist/es2019/presets/theme-to-design-tokens/utils/fuzzy-search.js

@@ -12,12 +12,10 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
     matchDict: {},
     items: {}
   };
-
   var levenshtein = function (str1, str2) {
     var current = [];
     var prev;
     var value;
-
     for (var i = 0; i <= str2.length; i++) {
       for (var j = 0; j <= str1.length; j++) {
         if (i && j) {
@@ -31,65 +29,52 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
         } else {
           value = i + j;
         }
-
         prev = current[j];
         current[j] = value;
       }
     }
-
     return current.pop();
-  }; // return an edit distance from 0 to 1
-
+  };
 
+  // return an edit distance from 0 to 1
   var _distance = function (str1, str2) {
     if (str1 === null && str2 === null) {
       throw new Error('Trying to compare two null values');
     }
-
     if (str1 === null || str2 === null) {
       return 0;
     }
-
     str1 = String(str1);
     str2 = String(str2);
     var distance = levenshtein(str1, str2);
-
     if (str1.length > str2.length) {
       return 1 - distance / str1.length;
     } else {
       return 1 - distance / str2.length;
     }
   };
-
   var _nonWordRe = /[^a-zA-Z0-9\u00C0-\u00FF, ]+/g;
-
   var _iterateGrams = function (value, gramSize) {
     gramSize = gramSize || 2;
     var simplified = '-' + value.toLowerCase().replace(_nonWordRe, '') + '-',
-        lenDiff = gramSize - simplified.length,
-        results = [];
-
+      lenDiff = gramSize - simplified.length,
+      results = [];
     if (lenDiff > 0) {
       for (var i = 0; i < lenDiff; ++i) {
         simplified += '-';
       }
     }
-
     for (var i = 0; i < simplified.length - gramSize + 1; ++i) {
       results.push(simplified.slice(i, i + gramSize));
     }
-
     return results;
   };
-
   var _gramCounter = function (value, gramSize) {
     // return an object where key=gram, value=number of occurrences
     gramSize = gramSize || 2;
-
     var result = {},
-        grams = _iterateGrams(value, gramSize),
-        i = 0;
-
+      grams = _iterateGrams(value, gramSize),
+      i = 0;
     for (i; i < grams.length; ++i) {
       if (grams[i] in result) {
         // @ts-expect-error
@@ -99,62 +84,51 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
         result[grams[i]] = 1;
       }
     }
-
     return result;
-  }; // the main functions
-
+  };
 
+  // the main functions
   fuzzyset.get = function (value, defaultValue, minMatchScore) {
     // check for value in set, returning defaultValue or null if none found
     if (minMatchScore === undefined) {
       minMatchScore = 0.33;
     }
-
     var result = this._get(value, minMatchScore);
-
     if (!result && typeof defaultValue !== 'undefined') {
       return defaultValue;
     }
-
     return result;
   };
-
   fuzzyset._get = function (value, minMatchScore) {
-    var results = []; // start with high gram size and if there are no results, go to lower gram sizes
-
+    var results = [];
+    // start with high gram size and if there are no results, go to lower gram sizes
     for (var gramSize = this.gramSizeUpper; gramSize >= this.gramSizeLower; --gramSize) {
       results = this.__get(value, gramSize, minMatchScore);
-
       if (results && results.length > 0) {
         return results;
       }
     }
-
     return null;
   };
-
   fuzzyset.__get = function (value, gramSize, minMatchScore) {
     var normalizedValue = this._normalizeStr(value),
-        matches = {},
-        gramCounts = _gramCounter(normalizedValue, gramSize),
-        items = this.items[gramSize],
-        sumOfSquareGramCounts = 0,
-        gram,
-        gramCount,
-        i,
-        index,
-        otherGramCount;
-
+      matches = {},
+      gramCounts = _gramCounter(normalizedValue, gramSize),
+      items = this.items[gramSize],
+      sumOfSquareGramCounts = 0,
+      gram,
+      gramCount,
+      i,
+      index,
+      otherGramCount;
     for (gram in gramCounts) {
       // @ts-expect-error
       gramCount = gramCounts[gram];
       sumOfSquareGramCounts += Math.pow(gramCount, 2);
-
       if (gram in this.matchDict) {
         for (i = 0; i < this.matchDict[gram].length; ++i) {
           index = this.matchDict[gram][i][0];
           otherGramCount = this.matchDict[gram][i][1];
-
           if (index in matches) {
             // @ts-expect-error
             matches[index] += gramCount * otherGramCount;
@@ -165,31 +139,26 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
         }
       }
     }
-
     function isEmptyObject(obj) {
       for (var prop in obj) {
         if (obj.hasOwnProperty(prop)) {
           return false;
         }
       }
-
       return true;
     }
-
     if (isEmptyObject(matches)) {
       return null;
     }
-
     var vectorNormal = Math.sqrt(sumOfSquareGramCounts),
-        results = [],
-        matchScore; // build a results list of [score, str]
-
+      results = [],
+      matchScore;
+    // build a results list of [score, str]
     for (var matchIndex in matches) {
       // @ts-expect-error
       matchScore = matches[matchIndex];
       results.push([matchScore / (vectorNormal * items[matchIndex][0]), items[matchIndex][1]]);
     }
-
     var sortDescending = function (a, b) {
       if (a[0] < b[0]) {
         return 1;
@@ -199,23 +168,19 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
         return 0;
       }
     };
-
     results.sort(sortDescending);
-
     if (this.useLevenshtein) {
       var newResults = [],
-          endIndex = Math.min(50, results.length); // truncate somewhat arbitrarily to 50
+        endIndex = Math.min(50, results.length);
+      // truncate somewhat arbitrarily to 50
       // @ts-expect-error
-
       for (var i = 0; i < endIndex; ++i) {
         // @ts-expect-error
         newResults.push([_distance(results[i][1], normalizedValue), results[i][1]]);
       }
-
       results = newResults;
       results.sort(sortDescending);
     }
-
     newResults = [];
     results.forEach(function (scoreWordPair) {
       if (scoreWordPair[0] >= minMatchScore) {
@@ -225,112 +190,90 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
     }.bind(this));
     return newResults;
   };
-
   fuzzyset.add = function (value) {
     var normalizedValue = this._normalizeStr(value);
-
     if (normalizedValue in this.exactSet) {
       return false;
     }
-
     var i = this.gramSizeLower;
-
     for (i; i < this.gramSizeUpper + 1; ++i) {
       this._add(value, i);
     }
   };
-
   fuzzyset._add = function (value, gramSize) {
     var normalizedValue = this._normalizeStr(value),
-        items = this.items[gramSize] || [],
-        index = items.length;
-
+      items = this.items[gramSize] || [],
+      index = items.length;
     items.push(0);
-
     var gramCounts = _gramCounter(normalizedValue, gramSize);
-
     var sumOfSquareGramCounts = 0;
     var gram;
     var gramCount;
-
     for (gram in gramCounts) {
       // @ts-expect-error
       gramCount = gramCounts[gram];
       sumOfSquareGramCounts += Math.pow(gramCount, 2);
-
       if (gram in this.matchDict) {
         this.matchDict[gram].push([index, gramCount]);
       } else {
         this.matchDict[gram] = [[index, gramCount]];
       }
     }
-
     var vectorNormal = Math.sqrt(sumOfSquareGramCounts);
     items[index] = [vectorNormal, normalizedValue];
     this.items[gramSize] = items;
     this.exactSet[normalizedValue] = value;
   };
-
   fuzzyset._normalizeStr = function (str) {
     if (Object.prototype.toString.call(str) !== '[object String]') {
       throw new Error('Must use a string as argument to FuzzySet functions');
     }
-
     return str.toLowerCase();
-  }; // return length of items in set
-
+  };
 
+  // return length of items in set
   fuzzyset.length = function () {
     var count = 0,
-        prop;
-
+      prop;
     for (prop in this.exactSet) {
       if (this.exactSet.hasOwnProperty(prop)) {
         count += 1;
       }
     }
-
     return count;
-  }; // return is set is empty
-
+  };
 
+  // return is set is empty
   fuzzyset.isEmpty = function () {
     for (var prop in this.exactSet) {
       if (this.exactSet.hasOwnProperty(prop)) {
         return false;
       }
     }
-
     return true;
-  }; // return list of values loaded into set
-
+  };
 
+  // return list of values loaded into set
   fuzzyset.values = function () {
     var values = [],
-        prop;
-
+      prop;
     for (prop in this.exactSet) {
       if (this.exactSet.hasOwnProperty(prop)) {
         values.push(this.exactSet[prop]);
       }
     }
-
     return values;
-  }; // initialization
-
+  };
 
+  // initialization
   var i = fuzzyset.gramSizeLower;
-
   for (i; i < fuzzyset.gramSizeUpper + 1; ++i) {
     fuzzyset.items[i] = [];
-  } // add all the items to the set
-
-
+  }
+  // add all the items to the set
   for (i = 0; i < arr.length; ++i) {
     fuzzyset.add(arr[i]);
   }
-
   return fuzzyset;
 };
-
 export default FuzzySet;

package/dist/es2019/presets/theme-to-design-tokens/utils/tokens.js

@@ -4,6 +4,5 @@ export const getUniqueWordsFromTokens = tokens.reduce((accum, val) => [...accum,
   if (!accum.includes(val)) {
     accum.push(val);
   }
-
   return accum;
 }, []);

package/dist/es2019/sinceRef.js

@@ -1,50 +1,42 @@
 import simpleGit from 'simple-git';
 import { ValidationError } from './types';
 const packageRegex = /"(@(?:atlaskit|atlassian|atlassiansox)\/.*)": "(.*)"/;
-
 const parseDiffLine = line => {
   const type = line.startsWith('-') ? 'deleted' : line.startsWith('+') ? 'added' : null;
   const match = line.match(packageRegex);
-
   if (!type || !match) {
     return null;
   }
-
   return {
     type,
     name: match[1],
     version: match[2]
   };
 };
+
 /** Returns packages that have been upgraded in package.json since ref. The version refers to their previous
  * version
  */
-
-
 export const getPackagesSinceRef = async ref => {
   const git = simpleGit();
   let commit;
-
   try {
     commit = await git.revparse(['--verify', ref]);
   } catch (e) {
     throw new ValidationError(`Invalid git ref "${ref}"`);
   }
-
   const diff = await git.diff([commit, '--', 'package.json']);
   const modifiedPackages = diff.split('\n').map(parseDiffLine).filter(pkg => Boolean(pkg));
   const addedPackages = new Map(modifiedPackages.filter(pkg => pkg.type === 'added').map(pkg => [pkg.name, pkg]));
+
   /* This is holds the previous version of packages that have been upgraded. Packages are treated as
    * upgraded if they have both an addition/deletion entry in the diff and their versions differ
    */
-
   const upgradedPackages = modifiedPackages.filter(pkg => {
     const addedEntry = addedPackages.get(pkg.name);
-
     if (pkg.type !== 'deleted' || !addedEntry) {
       return false;
     }
-
     return pkg.version !== addedEntry.version;
   }).map(({
     name,
@@ -55,7 +47,6 @@ export const getPackagesSinceRef = async ref => {
   }));
   return upgradedPackages;
 };
-
 if (require.main === module) {
   getPackagesSinceRef(process.argv[2]).then(res => console.log(res));
 }

package/dist/es2019/transforms.js

@@ -2,22 +2,18 @@ import path from 'path';
 import glob from 'glob';
 import semver from 'semver';
 import presets from './presets';
-
 const basePath = packages => {
   const packageDirectory = packages && packages.length > 0 ? [`{${packages.map(pkg => pkg.name).join(',')},}`] : ['@{atlaskit,atlassian,atlassiansox}', '*'];
   return path.join(process.cwd(), 'node_modules', ...packageDirectory, 'codemods');
 };
-
 export const hasTransform = transformPath => glob.sync(transformPath).length > 0;
-/** Retrieves transforms for `packages` if provided, otherwise all transforms including presets */
 
+/** Retrieves transforms for `packages` if provided, otherwise all transforms including presets */
 export const getTransforms = packages => {
   const transforms = [path.join(basePath(packages), '*.@(ts|tsx|js)'), path.join(basePath(packages), '*', 'index.@(ts|tsx|js)')];
-
   if (!packages) {
     transforms.unshift(...presets);
   }
-
   return transforms.map(transform => glob.sync(transform)).reduce((acc, val) => acc.concat(val), []).map(transform => parseTransformPath(transform)).filter(filterTransforms(packages)).sort();
 };
 export const parseTransformPath = transformPath => path.parse(transformPath);
@@ -27,35 +23,29 @@ export const getTransformPath = ({
 }) => `${dir}/${base}`;
 export const getTransformModule = transform => {
   const pathSegments = transform.dir.split(path.sep);
-  const nodeModulesIdx = pathSegments.indexOf('node_modules'); // pathSegments will be of the form [node_modules, '@atlaskit', 'avatar', 'codemods']
-
+  const nodeModulesIdx = pathSegments.indexOf('node_modules');
+  // pathSegments will be of the form [node_modules, '@atlaskit', 'avatar', 'codemods']
   return pathSegments.slice(nodeModulesIdx + 1, nodeModulesIdx + 3).join('/');
 };
 export const getTransformVersion = transform => {
   let transformName = transform.base;
-
   if (transformName.startsWith('index.')) {
     const pathSegments = transform.dir.split(path.sep);
     transformName = pathSegments[pathSegments.length - 1];
   }
-
   return transformName.split('-')[0];
 };
-
 const filterTransforms = packages => {
   if (!packages || packages.length === 0) {
     return () => true;
   }
-
   const packageMap = new Map(packages.map(pkg => [pkg.name, pkg.version]));
   return transform => {
     const transformVersion = getTransformVersion(transform);
     const pkgVersion = packageMap.get(getTransformModule(transform));
-
     if (pkgVersion === undefined) {
       throw Error(`No corresponding package found for transform "${transform.dir}/${transform.base}`);
     }
-
     if (transformVersion === 'next' || pkgVersion === null) {
       return true;
     } else if (semver.valid(transformVersion)) {

package/dist/es2019/types.js

@@ -1,5 +1,6 @@
 /** Converts required args to optional if they have a default
  * Example: export type UserFlags = Default<Flags, keyof typeof defaultFlags>;
  */
+
 export class ValidationError extends Error {}
 export class NoTransformsExistError extends Error {}