@atlaskit/codemod-cli 0.8.0 → 0.8.4

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

@@ -0,0 +1,340 @@
+/* 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;
+};
+
+export default FuzzySet;

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

@@ -0,0 +1,72 @@
+export 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'];
+export 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'];
+export 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: ['onBold'],
+  N800: ['text'],
+  background: ['background', 'default'],
+  backgroundActive: ['background', 'selected'],
+  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: ['text', 'link'],
+  linkHover: ['text', 'link', 'hovered'],
+  linkActive: ['text', '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/esm/presets/theme-to-design-tokens/utils/named-colors.js

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

package/dist/esm/types.js

@@ -1,3 +1,4 @@
+import _createClass from "@babel/runtime/helpers/createClass";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
@@ -22,7 +23,7 @@ export var ValidationError = /*#__PURE__*/function (_Error) {
     return _super.apply(this, arguments);
   }
 
-  return ValidationError;
+  return _createClass(ValidationError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));
 export var NoTransformsExistError = /*#__PURE__*/function (_Error2) {
   _inherits(NoTransformsExistError, _Error2);
@@ -35,5 +36,5 @@ export var NoTransformsExistError = /*#__PURE__*/function (_Error2) {
     return _super2.apply(this, arguments);
   }
 
-  return NoTransformsExistError;
+  return _createClass(NoTransformsExistError);
 }( /*#__PURE__*/_wrapNativeSuper(Error));

package/dist/esm/version.json

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

package/dist/types/presets/index.d.ts

@@ -3,5 +3,6 @@
  * in the final bundle
  */
 import './styled-to-emotion/styled-to-emotion';
+import './theme-to-design-tokens/theme-to-design-tokens';
 declare const presets: string[];
 export default presets;

package/dist/types/presets/theme-to-design-tokens/theme-to-design-tokens.d.ts

@@ -0,0 +1,2 @@
+import { API, FileInfo } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, debug?: boolean): string;

package/dist/types/presets/theme-to-design-tokens/types.d.ts

@@ -0,0 +1,2 @@
+import designTokens from '@atlaskit/tokens/token-names';
+export declare type DesignTokenName = keyof typeof designTokens;

package/dist/types/presets/theme-to-design-tokens/utils/ast-meta.d.ts

@@ -0,0 +1,4 @@
+import core from 'jscodeshift';
+export declare const getUniqueWordsFromTokens: string[];
+export declare function getMetaFromAncestors(j: core.JSCodeshift, path: any, meta?: string[]): string[];
+export declare function cleanMeta(meta: string[]): string[];

package/dist/types/presets/theme-to-design-tokens/utils/ast.d.ts

@@ -0,0 +1,3 @@
+import core from 'jscodeshift';
+export declare function isDecendantOfToken(j: core.JSCodeshift, path: any): boolean;
+export declare function isDecendantOfType(j: core.JSCodeshift, path: any, type: any): boolean;

package/dist/types/presets/theme-to-design-tokens/utils/color-difference.d.ts

@@ -0,0 +1,66 @@
+import type { DesignTokenName } from '../types';
+export declare type LegacyColorPalette = keyof typeof legacyColorPalette;
+export declare const legacyColorPalette: {
+    readonly R50: "#FFEBE6";
+    readonly R75: "#FFBDAD";
+    readonly R100: "#FF8F73";
+    readonly R200: "#FF7452";
+    readonly R300: "#FF5630";
+    readonly R400: "#DE350B";
+    readonly R500: "#BF2600";
+    readonly Y50: "#FFFAE6";
+    readonly Y75: "#FFF0B3";
+    readonly Y100: "#FFE380";
+    readonly Y200: "#FFC400";
+    readonly Y300: "#FFAB00";
+    readonly Y400: "#FF991F";
+    readonly Y500: "#FF8B00";
+    readonly G50: "#E3FCEF";
+    readonly G75: "#ABF5D1";
+    readonly G100: "#79F2C0";
+    readonly G200: "#57D9A3";
+    readonly G300: "#36B37E";
+    readonly G400: "#00875A";
+    readonly G500: "#006644";
+    readonly B50: "#DEEBFF";
+    readonly B75: "#B3D4FF";
+    readonly B100: "#4C9AFF";
+    readonly B200: "#2684FF";
+    readonly B300: "#0065FF";
+    readonly B400: "#0052CC";
+    readonly B500: "#0747A6";
+    readonly P50: "#EAE6FF";
+    readonly P75: "#C0B6F2";
+    readonly P100: "#998DD9";
+    readonly P200: "#8777D9";
+    readonly P300: "#6554C0";
+    readonly P400: "#5243AA";
+    readonly P500: "#403294";
+    readonly T50: "#E6FCFF";
+    readonly T75: "#B3F5FF";
+    readonly T100: "#79E2F2";
+    readonly T200: "#00C7E6";
+    readonly T300: "#00B8D9";
+    readonly T400: "#00A3BF";
+    readonly T500: "#008DA6";
+    readonly N0: "#FFFFFF";
+    readonly N10: "#FAFBFC";
+    readonly N20: "#F4F5F7";
+    readonly N30: "#EBECF0";
+    readonly N40: "#DFE1E6";
+    readonly N50: "#C1C7D0";
+    readonly N60: "#B3BAC5";
+    readonly N70: "#A5ADBA";
+    readonly N80: "#97A0AF";
+    readonly N90: "#8993A4";
+    readonly N100: "#7A869A";
+    readonly N200: "#6B778C";
+    readonly N300: "#5E6C84";
+    readonly N400: "#505F79";
+    readonly N500: "#42526E";
+    readonly N600: "#344563";
+    readonly N700: "#253858";
+    readonly N800: "#172B4D";
+    readonly N900: "#091E42";
+};
+export declare function findClosetMatchingToken(paletteName: string): DesignTokenName | undefined;

package/dist/types/presets/theme-to-design-tokens/utils/color-palette-tokens-map.d.ts

@@ -0,0 +1,21 @@
+import type { DesignTokenName } from '../types';
+import type { LegacyColorPalette } from './color-difference';
+interface TokenMap {
+    text: {
+        [key in LegacyColorPalette]?: DesignTokenName[];
+    };
+    background: {
+        [key in LegacyColorPalette]?: DesignTokenName[];
+    };
+    border: {
+        [key in LegacyColorPalette]?: DesignTokenName[];
+    };
+}
+interface ColorToTokenMap {
+    resting: TokenMap;
+    hover: TokenMap;
+    pressed: TokenMap;
+    disabled: TokenMap;
+}
+declare const colorMap: ColorToTokenMap;
+export default colorMap;

package/dist/types/presets/theme-to-design-tokens/utils/color-to-token.d.ts

@@ -0,0 +1,12 @@
+import type { DesignTokenName } from '../types';
+interface MetaOpts {
+    state: 'resting' | 'hover' | 'pressed' | 'disabled';
+    propertyName: string | undefined;
+}
+export interface TokenResult {
+    suggestion: string[];
+    fallbackNeeded: boolean;
+    confidence: 'unknown' | 'low' | 'medium' | 'high';
+}
+export default function colorToToken(paletteName: string, { state, propertyName }: MetaOpts, getLowConfidenceFuzzyResult?: () => DesignTokenName[]): TokenResult;
+export {};

package/dist/types/presets/theme-to-design-tokens/utils/color.d.ts

@@ -0,0 +1,4 @@
+export declare const isLegacyColor: (value: string) => boolean;
+export declare const isLegacyNamedColor: (value: string) => boolean;
+export declare const includesHardCodedColor: (raw: string) => boolean;
+export declare const isHardCodedColor: (value: string) => boolean;

package/dist/types/presets/theme-to-design-tokens/utils/fuzzy-search.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Fuzzy search ripped from the internet.
+ */
+declare const FuzzySet: (arr?: string[], useLevenshtein?: boolean | undefined, gramSizeLower?: number, gramSizeUpper?: number) => any;
+export default FuzzySet;

package/dist/types/presets/theme-to-design-tokens/utils/legacy-colors.d.ts

@@ -0,0 +1,3 @@
+export declare const legacyColors: string[];
+export declare const legacyColorMixins: string[];
+export declare const legacyColorMetaMap: Record<string, string[]>;

package/dist/types/presets/theme-to-design-tokens/utils/named-colors.d.ts

@@ -0,0 +1 @@
+export declare const namedColors: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/codemod-cli",
-  "version": "0.8.0",
+  "version": "0.8.4",
   "description": "A cli for distributing codemods for atlassian-frontend components and services",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -24,14 +24,16 @@
     "codemod-cli": "./bin/codemod-cli.js"
   },
   "dependencies": {
+    "@atlaskit/tokens": "^0.6.0",
     "@babel/runtime": "^7.0.0",
     "@types/chalk": "^2.2.0",
     "@types/jscodeshift": "^0.11.0",
     "chalk": "^2.1.0",
+    "chromatism": "^2.6.0",
     "enquirer": "^2.3.4",
     "glob": "^7.1.2",
     "jscodeshift": "^0.13.0",
-    "meow": "^6.0.0",
+    "meow": "^8.1.1",
     "projector-spawn": "^1.0.1",
     "semver": "^7.3.0",
     "simple-git": "^1.130.0"