@atlaskit/codemod-cli 0.8.3 → 0.8.6

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

@@ -0,0 +1,348 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/* eslint-disable */
+
+/**
+ * Fuzzy search ripped from the internet.
+ */
+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,
+    useLevenshtein: typeof useLevenshtein !== 'boolean' ? true : useLevenshtein,
+    exactSet: {},
+    matchDict: {},
+    items: {}
+  };
+
+  var levenshtein = function levenshtein(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 _distance(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 _iterateGrams(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 _gramCounter(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 sortDescending(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;
+};
+
+var _default = FuzzySet;
+exports.default = _default;

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

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.legacyColors = exports.legacyColorMixins = exports.legacyColorMetaMap = void 0;
+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;
+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;
+var 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']
+};
+exports.legacyColorMetaMap = legacyColorMetaMap;

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

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.namedColors = void 0;
+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/tokens.js

@@ -0,0 +1,38 @@
+"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 _tokenNames = _interopRequireDefault(require("@atlaskit/tokens/token-names"));
+
+var _renameMapping = _interopRequireDefault(require("@atlaskit/tokens/rename-mapping"));
+
+var tokens = Object.keys(_tokenNames.default).filter(function (t) {
+  return !t.includes('UNSAFE') && !t.includes('interaction');
+}).filter(function (t) {
+  return !_renameMapping.default.find(function (_ref) {
+    var path = _ref.path;
+    return t === path.replace(/\.[default]\g/, '');
+  });
+});
+exports.tokens = tokens;
+var getUniqueWordsFromTokens = Object.keys(_tokenNames.default).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);
+  }
+
+  return accum;
+}, []);
+exports.getUniqueWordsFromTokens = getUniqueWordsFromTokens;

package/dist/cjs/types.js

@@ -7,6 +7,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ValidationError = exports.NoTransformsExistError = void 0;
 
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
@@ -34,7 +36,7 @@ var ValidationError = /*#__PURE__*/function (_Error) {
     return _super.apply(this, arguments);
   }
 
-  return ValidationError;
+  return (0, _createClass2.default)(ValidationError);
 }( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
 
 exports.ValidationError = ValidationError;
@@ -49,7 +51,7 @@ var NoTransformsExistError = /*#__PURE__*/function (_Error2) {
     return _super2.apply(this, arguments);
   }
 
-  return NoTransformsExistError;
+  return (0, _createClass2.default)(NoTransformsExistError);
 }( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
 
 exports.NoTransformsExistError = NoTransformsExistError;

package/dist/cjs/version.json

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

package/dist/es2019/presets/index.js

@@ -5,5 +5,6 @@ import path from 'path';
  */
 
 import './styled-to-emotion/styled-to-emotion';
-const presets = ['styled-to-emotion'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js)`));
+import './theme-to-design-tokens/theme-to-design-tokens';
+const presets = ['styled-to-emotion', 'theme-to-design-tokens'].map(preset => path.join(__dirname, preset, `${preset}.@(ts|js|tsx)`));
 export default presets;

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

@@ -0,0 +1,100 @@
+/* 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';
+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: {
+      name: specifier
+    }
+  }).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'];
+
+  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
+  .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 => {
+    debug && console.log('file:', file.path);
+    insertTokenImport(j, source);
+    const key = path.value.property.type === 'Identifier' ? path.value.property.name : undefined;
+    const colorMeta = legacyColorMetaMap[key] || [];
+    const tokenId = getTokenFromNode(j, path, colorMeta);
+    j(path).replaceWith(buildToken(j, tokenId, path.value));
+    transformed = true;
+  });
+  source.find(j.ObjectProperty).filter(path => path.value.value.type === 'Identifier' && (isLegacyColor(path.value.value.name) || isLegacyNamedColor(path.value.value.name))).filter(path => hasImportSpecifier(j, source, path.value.value.type === 'Identifier' ? path.value.value.name : '', '@atlaskit/theme') || hasImportSpecifier(j, source, path.value.value.type === 'Identifier' ? path.value.value.name : '', '@atlaskit/theme/colors')).filter(path => !isDecendantOfToken(j, path.value.value)).forEach(path => {
+    const valuePath = path.get('value');
+    debug && console.log('file:', file.path);
+    insertTokenImport(j, source);
+    const colorMeta = legacyColorMetaMap[valuePath.name] || [];
+    const tokenId = getTokenFromNode(j, valuePath, colorMeta);
+    j(path).replaceWith(j.objectProperty(path.value.key, buildToken(j, tokenId, valuePath.value)));
+    transformed = true;
+  });
+  source.find(j.Identifier).filter(path => isLegacyColor(path.value.name) || isLegacyNamedColor(path.value.name)).filter(path => hasImportSpecifier(j, source, path.value.name, '@atlaskit/theme') || hasImportSpecifier(j, source, path.value.name, '@atlaskit/theme/colors')).filter(path => !['ImportSpecifier', 'MemberExpression', 'ObjectProperty'].includes(path.parentPath.value.type)).filter(path => !isDecendantOfToken(j, path)).forEach(path => {
+    debug && console.log('file:', file.path);
+    insertTokenImport(j, source);
+    const colorMeta = legacyColorMetaMap[path.value.name] || [];
+    const tokenId = getTokenFromNode(j, path, colorMeta);
+    j(path).replaceWith(buildToken(j, tokenId, path.value));
+    transformed = true;
+  });
+  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();
+    const colorMeta = legacyColorMetaMap[value] || [];
+    const tokenId = getTokenFromNode(j, path, colorMeta);
+    const tokenNode = buildToken(j, tokenId, path.value);
+    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/types.js

@@ -0,0 +1 @@
+export {};