@atlaskit/codemod-cli 0.8.3 → 0.8.6

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

@@ -0,0 +1,63 @@
+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
+    .reverse().some(str => {
+      const result = /(hover|active|disabled|focus)/.exec(str.toLowerCase());
+
+      if (result) {
+        meta.push(result[0]);
+        return true;
+      }
+    });
+    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) {
+  return meta.reduce((accum, val) => [...accum, ...(typeof val === 'string' ? val.split(/(?=[A-Z])/g).map(e => e.toLowerCase()) : [])], []).reduce((accum, val) => {
+    accum.push(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('warn', 'warning').replace('primary', 'bold').replace('info', 'bold').replace('secondary', 'subtle').replace('hyperlink', 'link').replace('anchor', 'link').replace('active', 'pressed').replace('hover', 'hovered').replace('dragged', 'overlay').replace('dragging', 'overlay').replace('drag', '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'));
+    return accum;
+  }, []).filter(val => {
+    return getUniqueWordsFromTokens.includes(val);
+  }).reduce((accum, val) => {
+    if (!accum.includes(val)) {
+      accum.push(val);
+    }
+
+    return accum;
+  }, []);
+}

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

@@ -0,0 +1,10 @@
+export function isDecendantOfToken(j, path) {
+  return j(path).closest(j.CallExpression, {
+    callee: {
+      name: 'token'
+    }
+  }).length > 0;
+}
+export function isDecendantOfType(j, path, type) {
+  return j(path).closest(type).length > 0;
+}

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

@@ -0,0 +1,35 @@
+import { legacyColorMixins, legacyColors } from './legacy-colors';
+import { namedColors } from './named-colors';
+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
+  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

@@ -0,0 +1,336 @@
+/* eslint-disable */
+
+/**
+ * Fuzzy search ripped from the internet.
+ */
+const FuzzySet = function (arr = [], useLevenshtein, gramSizeLower = 2, gramSizeUpper = 3) {
+  var fuzzyset = {
+    gramSizeLower: gramSizeLower,
+    gramSizeUpper: gramSizeUpper,
+    useLevenshtein: typeof useLevenshtein !== 'boolean' ? true : useLevenshtein,
+    exactSet: {},
+    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) {
+          if (str1.charAt(j - 1) === str2.charAt(i - 1)) {
+            // @ts-expect-error
+            value = prev;
+          } else {
+            // @ts-expect-error
+            value = Math.min(current[j], current[j - 1], prev) + 1;
+          }
+        } else {
+          value = i + j;
+        }
+
+        prev = current[j];
+        current[j] = value;
+      }
+    }
+
+    return current.pop();
+  }; // 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 = [];
+
+    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;
+
+    for (i; i < grams.length; ++i) {
+      if (grams[i] in result) {
+        // @ts-expect-error
+        result[grams[i]] += 1;
+      } else {
+        // @ts-expect-error
+        result[grams[i]] = 1;
+      }
+    }
+
+    return result;
+  }; // 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
+
+    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;
+
+    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;
+          } else {
+            // @ts-expect-error
+            matches[index] = gramCount * otherGramCount;
+          }
+        }
+      }
+    }
+
+    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]
+
+    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;
+      } else if (a[0] > b[0]) {
+        return -1;
+      } else {
+        return 0;
+      }
+    };
+
+    results.sort(sortDescending);
+
+    if (this.useLevenshtein) {
+      var newResults = [],
+          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) {
+        // @ts-expect-error
+        newResults.push([scoreWordPair[0], this.exactSet[scoreWordPair[1]]]);
+      }
+    }.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.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
+
+
+  fuzzyset.length = function () {
+    var count = 0,
+        prop;
+
+    for (prop in this.exactSet) {
+      if (this.exactSet.hasOwnProperty(prop)) {
+        count += 1;
+      }
+    }
+
+    return count;
+  }; // 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
+
+
+  fuzzyset.values = function () {
+    var values = [],
+        prop;
+
+    for (prop in this.exactSet) {
+      if (this.exactSet.hasOwnProperty(prop)) {
+        values.push(this.exactSet[prop]);
+      }
+    }
+
+    return values;
+  }; // initialization
+
+
+  var i = fuzzyset.gramSizeLower;
+
+  for (i; i < fuzzyset.gramSizeUpper + 1; ++i) {
+    fuzzyset.items[i] = [];
+  } // 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/legacy-colors.js

@@ -0,0 +1,74 @@
+export 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'];
+export 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'];
+export const legacyColorMetaMap = {
+  R50: ['danger'],
+  R75: ['danger'],
+  R100: ['danger'],
+  R200: ['danger'],
+  R300: ['danger'],
+  R400: ['danger'],
+  R500: ['danger'],
+  Y50: ['warning'],
+  Y75: ['warning'],
+  Y100: ['warning'],
+  Y200: ['warning'],
+  Y300: ['warning'],
+  Y400: ['warning'],
+  Y500: ['warning'],
+  G50: ['success'],
+  G75: ['success'],
+  G100: ['success'],
+  G200: ['success'],
+  G300: ['success'],
+  G400: ['success'],
+  G500: ['success'],
+  B50: ['brand'],
+  B75: ['brand'],
+  B100: ['brand'],
+  B200: ['brand'],
+  B300: ['brand'],
+  B400: ['brand'],
+  B500: ['brand'],
+  P50: ['discovery'],
+  P75: ['discovery'],
+  P100: ['discovery'],
+  P200: ['discovery'],
+  P300: ['discovery'],
+  P400: ['discovery'],
+  P500: ['discovery'],
+  T50: ['accent', 'teal'],
+  T75: ['accent', 'teal'],
+  T100: ['accent', 'teal'],
+  T200: ['accent', 'teal'],
+  T300: ['accent', 'teal'],
+  T400: ['accent', 'teal'],
+  T500: ['accent', 'teal'],
+  N0: ['inverse'],
+  N700: ['text'],
+  N800: ['text'],
+  N900: ['text'],
+  background: ['background', 'default'],
+  backgroundActive: ['background', 'pressed'],
+  backgroundHover: ['background', 'hovered'],
+  backgroundOnLayer: ['background', 'blanket'],
+  text: ['text'],
+  textHover: ['text', 'subtle'],
+  textActive: ['text', 'link', 'pressed'],
+  subtleText: ['text', 'subtlest'],
+  placeholderText: ['text', 'subtlest'],
+  heading: ['text'],
+  subtleHeading: ['text', 'subtle'],
+  link: ['link'],
+  linkHover: ['link', 'hovered'],
+  linkActive: ['link', 'pressed'],
+  linkOutline: ['border', 'selected'],
+  primary: ['brand'],
+  blue: ['accent', 'blue'],
+  teal: ['accent', 'teal'],
+  purple: ['accent', 'purple'],
+  red: ['accent', 'red'],
+  yellow: ['accent', 'orange'],
+  green: ['accent', 'green'],
+  grey: ['background', 'neutral'],
+  skeleton: ['background', 'neutral']
+};

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

@@ -0,0 +1 @@
+export 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'];

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

@@ -0,0 +1,12 @@
+import designTokens from '@atlaskit/tokens/token-names';
+import renameMapping from '@atlaskit/tokens/rename-mapping';
+export const tokens = Object.keys(designTokens).filter(t => !t.includes('UNSAFE') && !t.includes('interaction')).filter(t => !renameMapping.find(({
+  path
+}) => t === path.replace(/\.[default]\g/, '')));
+export const getUniqueWordsFromTokens = Object.keys(designTokens).reduce((accum, val) => [...accum, ...val.split('.')], []).reduce((accum, val) => [...accum, ...val.split(/(?=[A-Z])/g).map(e => e.toLowerCase())], []).reduce((accum, val) => {
+  if (!accum.includes(val)) {
+    accum.push(val);
+  }
+
+  return accum;
+}, []);

package/dist/es2019/version.json

@@ -1,4 +1,4 @@
 {
 	"name": "@atlaskit/codemod-cli",
-	"version": "0.8.3"
+	"version": "0.8.6"
 }

package/dist/esm/main.js

@@ -9,9 +9,9 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 import chalk from 'chalk';
 import fs from 'fs';
@@ -340,7 +340,7 @@ function _main() {
           case 4:
             _yield$parseArgs = _context5.sent;
             packages = _yield$parseArgs.packages;
-            _process$env$_PACKAGE = "0.8.3", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
+            _process$env$_PACKAGE = "0.8.6", _PACKAGE_VERSION_ = _process$env$_PACKAGE === void 0 ? '0.0.0-dev' : _process$env$_PACKAGE;
             logger.log(chalk.bgBlue(chalk.black("\uD83D\uDCDA Atlassian-Frontend codemod library @ ".concat(_PACKAGE_VERSION_, " \uD83D\uDCDA"))));
 
             if (packages && packages.length > 0) {

package/dist/esm/presets/index.js

@@ -5,7 +5,8 @@ import path from 'path';
  */
 
 import './styled-to-emotion/styled-to-emotion';
-var presets = ['styled-to-emotion'].map(function (preset) {
-  return path.join(__dirname, preset, "".concat(preset, ".@(ts|js)"));
+import './theme-to-design-tokens/theme-to-design-tokens';
+var presets = ['styled-to-emotion', 'theme-to-design-tokens'].map(function (preset) {
+  return path.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
 export default presets;