@atlaskit/codemod-cli 0.13.3 → 0.14.0

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

@@ -1,17 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.cleanMeta = cleanMeta;
 exports.getMetaFromAncestors = getMetaFromAncestors;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _ast = require("./ast");
 var _tokens = require("./tokens");
-function getMetaFromAncestors(j, path, meta = []) {
-  const parent = path.parentPath;
-  const grandParent = parent && parent.parentPath;
+function getMetaFromAncestors(j, path) {
+  var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  var parent = path.parentPath;
+  var grandParent = parent && parent.parentPath;
   if (parent && parent.value.type === 'ObjectProperty') {
-    let value = '';
+    var value = '';
     if (parent.value.key.type === 'Literal' || parent.value.key.type === 'StringLiteral' || parent.value.key.type === 'NumericLiteral') {
       value = parent.value.key.value.toString();
     } else {
@@ -20,13 +23,19 @@ function getMetaFromAncestors(j, path, meta = []) {
     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)
+    var expressionIndex = grandParent.value.expressions.findIndex(function (exp) {
+      return exp.name === path.value.name;
+    });
+    var quasi = grandParent.value.quasis[expressionIndex];
+    var propertyName = (quasi.value.cooked || quasi.value.raw || '').replace(/\n/g, '').split(/;|{|}/).filter(function (el) {
+      return !el.match(/\.|\@|\(|\)/);
+    }).pop().split(/:/g)[0].trim();
+    grandParent.value.quasis.slice(0, expressionIndex + 1).map(function (q) {
+      return 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());
+    .reverse().some(function (str) {
+      var result = /(hover|active|disabled|focus)/.exec(str.toLowerCase());
       if (result) {
         meta.push(result[0]);
         return true;
@@ -39,11 +48,11 @@ function getMetaFromAncestors(j, path, meta = []) {
       meta.push(parent.value.name.name);
     }
   }
-  const closestJSXElement = (0, _ast.getClosestDecendantOfType)(j, path, j.JSXOpeningElement);
+  var closestJSXElement = (0, _ast.getClosestDecendantOfType)(j, path, j.JSXOpeningElement);
   if (closestJSXElement) {
-    const jsxElementName = closestJSXElement.value.name.name;
-    const nameComponents = jsxElementName.replace(/([a-z])([A-Z])/g, '$1 $2').split(' ');
-    meta.push(...nameComponents);
+    var jsxElementName = closestJSXElement.value.name.name;
+    var nameComponents = jsxElementName.replace(/([a-z])([A-Z])/g, '$1 $2').split(' ');
+    meta.push.apply(meta, (0, _toConsumableArray2.default)(nameComponents));
   }
   if (parent && parent.value.type === 'VariableDeclarator') {
     meta.push(parent.value.id.name);
@@ -54,11 +63,17 @@ function getMetaFromAncestors(j, path, meta = []) {
   return meta;
 }
 function cleanMeta(meta) {
-  return meta.reduce((accum, val) => [...accum, ...(typeof val === 'string' ? val.split(/(?=[A-Z])/g).map(e => e.toLowerCase()) : [])], []).reduce((accum, val) => {
-    const cleanVal = val.replace(/:/g, '').replace(/,/g, '').replace('grey', 'neutral').replace('skeleton', 'neutral').replace('texts', 'text').replace('red', 'danger').replace('error', 'danger').replace('invalid', 'danger').replace('removed', 'danger').replace('removal', 'danger').replace('remove', 'danger').replace('focus', 'focused').replace('valid', 'success').replace('successful', 'success').replace('risk', 'warning').replace('caution', 'warning').replace('primary', 'bold').replace('secondary', 'subtle').replace('hyperlink', 'link').replace('anchor', 'link').replace('active', 'pressed').replace('hover', 'hovered').replace('card', 'raised').replace('dragged', 'surface overlay').replace('dragging', 'surface overlay').replace('drag', 'surface overlay').replace('background-color', 'background').replace('color', 'text').replace('icons', 'icon').replace('glyph', 'icon').replace('stroke', 'border').replace('border-left', 'border').replace('border-right', 'border').replace('border-top', 'border').replace('border-bottom', 'border').replace('box-shadow', 'shadow');
-    accum.push(...cleanVal.split(' '));
+  return meta.reduce(function (accum, val) {
+    return [].concat((0, _toConsumableArray2.default)(accum), (0, _toConsumableArray2.default)(typeof val === 'string' ? val.split(/(?=[A-Z])/g).map(function (e) {
+      return e.toLowerCase();
+    }) : []));
+  }, []).reduce(function (accum, val) {
+    var cleanVal = val.replace(/:/g, '').replace(/,/g, '').replace('grey', 'neutral').replace('skeleton', 'neutral').replace('texts', 'text').replace('red', 'danger').replace('error', 'danger').replace('invalid', 'danger').replace('removed', 'danger').replace('removal', 'danger').replace('remove', 'danger').replace('focus', 'focused').replace('valid', 'success').replace('successful', 'success').replace('risk', 'warning').replace('caution', 'warning').replace('primary', 'bold').replace('secondary', 'subtle').replace('hyperlink', 'link').replace('anchor', 'link').replace('active', 'pressed').replace('hover', 'hovered').replace('card', 'raised').replace('dragged', 'surface overlay').replace('dragging', 'surface overlay').replace('drag', 'surface overlay').replace('background-color', 'background').replace('color', 'text').replace('icons', 'icon').replace('glyph', 'icon').replace('stroke', 'border').replace('border-left', 'border').replace('border-right', 'border').replace('border-top', 'border').replace('border-bottom', 'border').replace('box-shadow', 'shadow');
+    accum.push.apply(accum, (0, _toConsumableArray2.default)(cleanVal.split(' ')));
     return accum;
-  }, []).filter(val => _tokens.getUniqueWordsFromTokens.includes(val)).reduce((accum, val) => {
+  }, []).filter(function (val) {
+    return _tokens.getUniqueWordsFromTokens.includes(val);
+  }).reduce(function (accum, val) {
     if (!accum.includes(val)) {
       accum.push(val);
     }

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

@@ -8,7 +8,7 @@ exports.isDecendantOfToken = isDecendantOfToken;
 exports.isParentOfToken = isParentOfToken;
 var _utils = require("@codeshift/utils");
 function isDecendantOfToken(j, path) {
-  if (path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
+  if ('type' in path && path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
     return true;
   }
   return j(path).closest(j.CallExpression, {

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

@@ -3,38 +3,46 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isLegacyNamedColor = exports.isLegacyColor = exports.isHardCodedColor = exports.includesHardCodedColor = void 0;
+exports.includesHardCodedColor = void 0;
+exports.isBoldColor = isBoldColor;
+exports.isLegacyNamedColor = exports.isLegacyColor = exports.isHardCodedColor = void 0;
 var _legacyColors = require("./legacy-colors");
 var _namedColors = require("./named-colors");
-const isLegacyColor = value => _legacyColors.legacyColors.includes(value);
+var isLegacyColor = function isLegacyColor(value) {
+  return _legacyColors.legacyColors.includes(value);
+};
 exports.isLegacyColor = isLegacyColor;
-const isLegacyNamedColor = value => _legacyColors.legacyColorMixins.includes(value);
+var isLegacyNamedColor = function isLegacyNamedColor(value) {
+  return _legacyColors.legacyColorMixins.includes(value);
+};
 exports.isLegacyNamedColor = isLegacyNamedColor;
-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())) {
+var colorRegexp = /#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})\b|(?:rgb|rgba|hsl|hsla|lch|lab|color)\([^\)]*\)/;
+var includesHardCodedColor = function includesHardCodedColor(raw) {
+  var value = raw.toLowerCase();
+  if (colorRegexp.exec(value)) {
     return true;
   }
-  for (let i = 0; i < _namedColors.namedColors.length; i++) {
-    if (value.includes(`${_namedColors.namedColors[i]};`)) {
+  for (var i = 0; i < _namedColors.namedColors.length; i++) {
+    if (value.includes("".concat(_namedColors.namedColors[i], ";"))) {
       return true;
     }
   }
   return false;
 };
 exports.includesHardCodedColor = includesHardCodedColor;
-const isHardCodedColor = value => {
-  if (_namedColors.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(')) {
+var isHardCodedColor = function isHardCodedColor(raw) {
+  var value = raw.toLowerCase();
+  if (_namedColors.namedColors.includes(value)) {
     return true;
   }
-  if (value.startsWith('#') && (
-  // short hex, hex, or hex with alpha
-  value.length === 4 || value.length === 7 || value.length === 9)) {
+  var match = value.toLowerCase().match(colorRegexp);
+  if (match && match[0] === value) {
     return true;
   }
   return false;
 };
-exports.isHardCodedColor = isHardCodedColor;
+exports.isHardCodedColor = isHardCodedColor;
+function isBoldColor(color) {
+  var number = parseInt(color.replace(/^./, ''), 10);
+  return number > 300;
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.containsReplaceableCSSDeclarations = containsReplaceableCSSDeclarations;
+exports.findEndIndexOfCSSExpression = findEndIndexOfCSSExpression;
+var _cssToDesignTokens = require("../../css-to-design-tokens/css-to-design-tokens");
+function containsReplaceableCSSDeclarations(input) {
+  var cssPattern = /(\S+)\s*:/g;
+  var match;
+  while ((match = cssPattern.exec(input)) !== null) {
+    if ((0, _cssToDesignTokens.isColorProperty)(match[1])) {
+      return true;
+    }
+  }
+  return false;
+}
+function findEndIndexOfCSSExpression(text, isAtEndOfInput) {
+  // CSS expression can end *on* a semicolon or *before* a brace. In either
+  // case we treat the remaining part of the value to cover one character
+  // before that symbol.
+  var semicolonIndex = text.indexOf(';');
+  var braceIndex = text.indexOf('}');
+  if (semicolonIndex === -1 && braceIndex === -1) {
+    if (isAtEndOfInput) {
+      return text.length;
+    } else {
+      return null;
+    }
+  } else if (semicolonIndex === -1) {
+    return braceIndex - 1;
+  } else if (braceIndex === -1) {
+    return semicolonIndex - 1;
+  } else {
+    return Math.min(semicolonIndex, braceIndex) - 1;
+  }
+}

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

@@ -9,7 +9,11 @@ exports.default = void 0;
 /**
  * Fuzzy search ripped from the internet.
  */
-const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSizeUpper = 3) {
+var FuzzySet = function FuzzySet() {
+  var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var useLevenshtein = arguments.length > 1 ? arguments[1] : undefined;
+  var gramSizeLower = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 2;
+  var gramSizeUpper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 3;
   var fuzzyset = {
     gramSizeLower: gramSizeLower,
     gramSizeUpper: gramSizeUpper,
@@ -18,7 +22,7 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
     matchDict: {},
     items: {}
   };
-  var levenshtein = function (str1, str2) {
+  var levenshtein = function levenshtein(str1, str2) {
     var current = [];
     var prev;
     var value;
@@ -43,7 +47,7 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
   };
 
   // return an edit distance from 0 to 1
-  var _distance = function (str1, str2) {
+  var _distance = function _distance(str1, str2) {
     if (str1 === null && str2 === null) {
       throw new Error('Trying to compare two null values');
     }
@@ -60,7 +64,7 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
     }
   };
   var _nonWordRe = /[^a-zA-Z0-9\u00C0-\u00FF, ]+/g;
-  var _iterateGrams = function (value, gramSize) {
+  var _iterateGrams = function _iterateGrams(value, gramSize) {
     gramSize = gramSize || 2;
     var simplified = '-' + value.toLowerCase().replace(_nonWordRe, '') + '-',
       lenDiff = gramSize - simplified.length,
@@ -75,7 +79,7 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
     }
     return results;
   };
-  var _gramCounter = function (value, gramSize) {
+  var _gramCounter = function _gramCounter(value, gramSize) {
     // return an object where key=gram, value=number of occurrences
     gramSize = gramSize || 2;
     var result = {},
@@ -165,7 +169,7 @@ const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSize
       matchScore = matches[matchIndex];
       results.push([matchScore / (vectorNormal * items[matchIndex][0]), items[matchIndex][1]]);
     }
-    var sortDescending = function (a, b) {
+    var sortDescending = function sortDescending(a, b) {
       if (a[0] < b[0]) {
         return 1;
       } else if (a[0] > b[0]) {

package/dist/cjs/presets/theme-to-design-tokens/utils/legacy-colors.js

@@ -4,11 +4,11 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.legacyColors = exports.legacyColorMixins = exports.legacyColorMetaMap = void 0;
-const legacyColors = ['R50', 'R75', 'R100', 'R200', 'R300', 'R400', 'R500', 'Y50', 'Y75', 'Y100', 'Y200', 'Y300', 'Y400', 'Y500', 'G50', 'G75', 'G100', 'G200', 'G300', 'G400', 'G500', 'B50', 'B75', 'B100', 'B200', 'B300', 'B400', 'B500', 'P50', 'P75', 'P100', 'P200', 'P300', 'P400', 'P500', 'T50', 'T75', 'T100', 'T200', 'T300', 'T400', 'T500', 'N0', 'N10', 'N20', 'N30', 'N40', 'N50', 'N60', 'N70', 'N80', 'N90', 'N100', 'N200', 'N300', 'N400', 'N500', 'N600', 'N700', 'N800', 'N900', 'N10A', 'N20A', 'N30A', 'N40A', 'N50A', 'N60A', 'N70A', 'N80A', 'N90A', 'N100A', 'N200A', 'N300A', 'N400A', 'N500A', 'N600A', 'N700A', 'N800A', 'DN900', 'DN800', 'DN700', 'DN600', 'DN500', 'DN400', 'DN300', 'DN200', 'DN100', 'DN90', 'DN80', 'DN70', 'DN60', 'DN50', 'DN40', 'DN30', 'DN20', 'DN10', 'DN0', 'DN800A', 'DN700A', 'DN600A', 'DN500A', 'DN400A', 'DN300A', 'DN200A', 'DN100A', 'DN90A', 'DN80A', 'DN70A', 'DN60A', 'DN50A', 'DN40A', 'DN30A', 'DN20A', 'DN10A'];
+var legacyColors = ['R50', 'R75', 'R100', 'R200', 'R300', 'R400', 'R500', 'Y50', 'Y75', 'Y100', 'Y200', 'Y300', 'Y400', 'Y500', 'G50', 'G75', 'G100', 'G200', 'G300', 'G400', 'G500', 'B50', 'B75', 'B100', 'B200', 'B300', 'B400', 'B500', 'P50', 'P75', 'P100', 'P200', 'P300', 'P400', 'P500', 'T50', 'T75', 'T100', 'T200', 'T300', 'T400', 'T500', 'N0', 'N10', 'N20', 'N30', 'N40', 'N50', 'N60', 'N70', 'N80', 'N90', 'N100', 'N200', 'N300', 'N400', 'N500', 'N600', 'N700', 'N800', 'N900', 'N10A', 'N20A', 'N30A', 'N40A', 'N50A', 'N60A', 'N70A', 'N80A', 'N90A', 'N100A', 'N200A', 'N300A', 'N400A', 'N500A', 'N600A', 'N700A', 'N800A', 'DN900', 'DN800', 'DN700', 'DN600', 'DN500', 'DN400', 'DN300', 'DN200', 'DN100', 'DN90', 'DN80', 'DN70', 'DN60', 'DN50', 'DN40', 'DN30', 'DN20', 'DN10', 'DN0', 'DN800A', 'DN700A', 'DN600A', 'DN500A', 'DN400A', 'DN300A', 'DN200A', 'DN100A', 'DN90A', 'DN80A', 'DN70A', 'DN60A', 'DN50A', 'DN40A', 'DN30A', 'DN20A', 'DN10A'];
 exports.legacyColors = legacyColors;
-const legacyColorMixins = ['background', 'backgroundActive', 'backgroundHover', 'backgroundOnLayer', 'text', 'textHover', 'textActive', 'subtleText', 'placeholderText', 'heading', 'subtleHeading', 'codeBlock', 'link', 'linkHover', 'linkActive', 'linkOutline', 'primary', 'blue', 'teal', 'purple', 'red', 'yellow', 'green', 'skeleton'];
+var legacyColorMixins = ['background', 'backgroundActive', 'backgroundHover', 'backgroundOnLayer', 'text', 'textHover', 'textActive', 'subtleText', 'placeholderText', 'heading', 'subtleHeading', 'codeBlock', 'link', 'linkHover', 'linkActive', 'linkOutline', 'primary', 'blue', 'teal', 'purple', 'red', 'yellow', 'green', 'skeleton'];
 exports.legacyColorMixins = legacyColorMixins;
-const legacyColorMetaMap = {
+var legacyColorMetaMap = {
   R50: ['danger'],
   R75: ['danger'],
   R100: ['danger'],

package/dist/cjs/presets/theme-to-design-tokens/utils/named-colors.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.namedColors = void 0;
-const namedColors = ['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'];
+var namedColors = ['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple'];
 exports.namedColors = namedColors;

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findFirstNonspaceIndexAfter = findFirstNonspaceIndexAfter;
+exports.kebabize = void 0;
+exports.splitAtIndex = splitAtIndex;
+var kebabize = function kebabize(str) {
+  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, function ($, ofs) {
+    return (ofs ? '-' : '') + $.toLowerCase();
+  });
+};
+exports.kebabize = kebabize;
+function findFirstNonspaceIndexAfter(text, index) {
+  var rest = text.slice(index + 1);
+  var indexInRest = rest.search(/\S/);
+  if (indexInRest === -1) {
+    return text.length;
+  } else {
+    return index + 1 + indexInRest;
+  }
+}
+function splitAtIndex(text, index) {
+  return [text.slice(0, index), text.slice(index)];
+}

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

@@ -1,13 +1,27 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.tokens = exports.getUniqueWordsFromTokens = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _tokensRaw = require("@atlaskit/tokens/tokens-raw");
-const tokens = _tokensRaw.light.filter(t => t.attributes.state === 'active').map(t => t.name.replace(/\.\[default\]/g, '')).filter(t => !t.includes('UNSAFE') && !t.includes('interaction') && !t.includes('chart') && !t.includes('elevation.shadow.overflow'));
+var tokens = _tokensRaw.light.filter(function (t) {
+  return t.attributes.state === 'active';
+}).map(function (t) {
+  return t.name.replace(/\.\[default\]/g, '');
+}).filter(function (t) {
+  return !t.includes('UNSAFE') && !t.includes('interaction') && !t.includes('chart') && !t.includes('elevation.shadow.overflow');
+});
 exports.tokens = tokens;
-const getUniqueWordsFromTokens = tokens.reduce((accum, val) => [...accum, ...val.split('.')], []).reduce((accum, val) => [...accum, ...val.split(/(?=[A-Z])/g).map(e => e.toLowerCase())], []).reduce((accum, val) => {
+var getUniqueWordsFromTokens = tokens.reduce(function (accum, val) {
+  return [].concat((0, _toConsumableArray2.default)(accum), (0, _toConsumableArray2.default)(val.split('.')));
+}, []).reduce(function (accum, val) {
+  return [].concat((0, _toConsumableArray2.default)(accum), (0, _toConsumableArray2.default)(val.split(/(?=[A-Z])/g).map(function (e) {
+    return e.toLowerCase();
+  })));
+}, []).reduce(function (accum, val) {
   if (!accum.includes(val)) {
     accum.push(val);
   }

package/dist/cjs/sinceRef.js

@@ -5,17 +5,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getPackagesSinceRef = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _simpleGit = _interopRequireDefault(require("simple-git"));
 var _types = require("./types");
-const packageRegex = /"(@(?:atlaskit|atlassian|atlassiansox)\/.*)": "(.*)"/;
-const parseDiffLine = line => {
-  const type = line.startsWith('-') ? 'deleted' : line.startsWith('+') ? 'added' : null;
-  const match = line.match(packageRegex);
+var packageRegex = /"(@(?:atlaskit|atlassian|atlassiansox)\/.*)": "(.*)"/;
+var parseDiffLine = function parseDiffLine(line) {
+  var type = line.startsWith('-') ? 'deleted' : line.startsWith('+') ? 'added' : null;
+  var match = line.match(packageRegex);
   if (!type || !match) {
     return null;
   }
   return {
-    type,
+    type: type,
     name: match[1],
     version: match[2]
   };
@@ -24,37 +26,69 @@ const parseDiffLine = line => {
 /** Returns packages that have been upgraded in package.json since ref. The version refers to their previous
  * version
  */
-const getPackagesSinceRef = async ref => {
-  const git = (0, _simpleGit.default)();
-  let commit;
-  try {
-    commit = await git.revparse(['--verify', ref]);
-  } catch (e) {
-    throw new _types.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,
-    version
-  }) => ({
-    name,
-    version
+var getPackagesSinceRef = /*#__PURE__*/function () {
+  var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(ref) {
+    var git, commit, diff, modifiedPackages, addedPackages, upgradedPackages;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          git = (0, _simpleGit.default)();
+          _context.prev = 1;
+          _context.next = 4;
+          return git.revparse(['--verify', ref]);
+        case 4:
+          commit = _context.sent;
+          _context.next = 10;
+          break;
+        case 7:
+          _context.prev = 7;
+          _context.t0 = _context["catch"](1);
+          throw new _types.ValidationError("Invalid git ref \"".concat(ref, "\""));
+        case 10:
+          _context.next = 12;
+          return git.diff([commit, '--', 'package.json']);
+        case 12:
+          diff = _context.sent;
+          modifiedPackages = diff.split('\n').map(parseDiffLine).filter(function (pkg) {
+            return Boolean(pkg);
+          });
+          addedPackages = new Map(modifiedPackages.filter(function (pkg) {
+            return pkg.type === 'added';
+          }).map(function (pkg) {
+            return [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
+           */
+          upgradedPackages = modifiedPackages.filter(function (pkg) {
+            var addedEntry = addedPackages.get(pkg.name);
+            if (pkg.type !== 'deleted' || !addedEntry) {
+              return false;
+            }
+            return pkg.version !== addedEntry.version;
+          }).map(function (_ref2) {
+            var name = _ref2.name,
+              version = _ref2.version;
+            return {
+              name: name,
+              version: version
+            };
+          });
+          return _context.abrupt("return", upgradedPackages);
+        case 17:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[1, 7]]);
   }));
-  return upgradedPackages;
-};
+  return function getPackagesSinceRef(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
 exports.getPackagesSinceRef = getPackagesSinceRef;
 if (require.main === module) {
-  getPackagesSinceRef(process.argv[2]).then(res => console.log(res));
+  // eslint-disable-next-line no-console
+  getPackagesSinceRef(process.argv[2]).then(function (res) {
+    return console.log(res);
+  });
 }

package/dist/cjs/transforms.js

@@ -5,59 +5,77 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.parseTransformPath = exports.hasTransform = exports.getTransforms = exports.getTransformVersion = exports.getTransformPath = exports.getTransformModule = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _path = _interopRequireDefault(require("path"));
 var _glob = _interopRequireDefault(require("glob"));
 var _semver = _interopRequireDefault(require("semver"));
 var _presets = _interopRequireDefault(require("./presets"));
-const basePath = packages => {
-  const packageDirectory = packages && packages.length > 0 ? [`{${packages.map(pkg => pkg.name).join(',')},}`] : ['@{atlaskit,atlassian,atlassiansox}', '*'];
-  return _path.default.join(process.cwd(), 'node_modules', ...packageDirectory, 'codemods');
+var basePath = function basePath(packages) {
+  var packageDirectory = packages && packages.length > 0 ? ["{".concat(packages.map(function (pkg) {
+    return pkg.name;
+  }).join(','), ",}")] : ['@{atlaskit,atlassian,atlassiansox}', '*'];
+  return _path.default.join.apply(_path.default, [process.cwd(), 'node_modules'].concat(packageDirectory, ['codemods']));
+};
+var hasTransform = function hasTransform(transformPath) {
+  return _glob.default.sync(transformPath).length > 0;
 };
-const hasTransform = transformPath => _glob.default.sync(transformPath).length > 0;
 
 /** Retrieves transforms for `packages` if provided, otherwise all transforms including presets */
 exports.hasTransform = hasTransform;
-const getTransforms = packages => {
-  const transforms = [_path.default.join(basePath(packages), '*.@(ts|tsx|js)'), _path.default.join(basePath(packages), '*', 'index.@(ts|tsx|js)')];
+var getTransforms = function getTransforms(packages) {
+  var transforms = [_path.default.join(basePath(packages), '*.@(ts|tsx|js)'), _path.default.join(basePath(packages), '*', 'index.@(ts|tsx|js)')];
   if (!packages) {
-    transforms.unshift(..._presets.default);
+    transforms.unshift.apply(transforms, (0, _toConsumableArray2.default)(_presets.default));
   }
-  return transforms.map(transform => _glob.default.sync(transform)).reduce((acc, val) => acc.concat(val), []).map(transform => parseTransformPath(transform)).filter(filterTransforms(packages)).sort();
+  return transforms.map(function (transform) {
+    return _glob.default.sync(transform);
+  }).reduce(function (acc, val) {
+    return acc.concat(val);
+  }, []).map(function (transform) {
+    return parseTransformPath(transform);
+  }).filter(filterTransforms(packages)).sort();
 };
 exports.getTransforms = getTransforms;
-const parseTransformPath = transformPath => _path.default.parse(transformPath);
+var parseTransformPath = function parseTransformPath(transformPath) {
+  return _path.default.parse(transformPath);
+};
 exports.parseTransformPath = parseTransformPath;
-const getTransformPath = ({
-  dir,
-  base
-}) => `${dir}/${base}`;
+var getTransformPath = function getTransformPath(_ref) {
+  var dir = _ref.dir,
+    base = _ref.base;
+  return "".concat(dir, "/").concat(base);
+};
 exports.getTransformPath = getTransformPath;
-const getTransformModule = transform => {
-  const pathSegments = transform.dir.split(_path.default.sep);
-  const nodeModulesIdx = pathSegments.indexOf('node_modules');
+var getTransformModule = function getTransformModule(transform) {
+  var pathSegments = transform.dir.split(_path.default.sep);
+  var nodeModulesIdx = pathSegments.indexOf('node_modules');
   // pathSegments will be of the form [node_modules, '@atlaskit', 'avatar', 'codemods']
   return pathSegments.slice(nodeModulesIdx + 1, nodeModulesIdx + 3).join('/');
 };
 exports.getTransformModule = getTransformModule;
-const getTransformVersion = transform => {
-  let transformName = transform.base;
+var getTransformVersion = function getTransformVersion(transform) {
+  var transformName = transform.base;
   if (transformName.startsWith('index.')) {
-    const pathSegments = transform.dir.split(_path.default.sep);
+    var pathSegments = transform.dir.split(_path.default.sep);
     transformName = pathSegments[pathSegments.length - 1];
   }
   return transformName.split('-')[0];
 };
 exports.getTransformVersion = getTransformVersion;
-const filterTransforms = packages => {
+var filterTransforms = function filterTransforms(packages) {
   if (!packages || packages.length === 0) {
-    return () => true;
+    return function () {
+      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));
+  var packageMap = new Map(packages.map(function (pkg) {
+    return [pkg.name, pkg.version];
+  }));
+  return function (transform) {
+    var transformVersion = getTransformVersion(transform);
+    var pkgVersion = packageMap.get(getTransformModule(transform));
     if (pkgVersion === undefined) {
-      throw Error(`No corresponding package found for transform "${transform.dir}/${transform.base}`);
+      throw Error("No corresponding package found for transform \"".concat(transform.dir, "/").concat(transform.base));
     }
     if (transformVersion === 'next' || pkgVersion === null) {
       return true;