@atlaskit/codemod-cli 0.8.0 → 0.8.4

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

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var colorMap = {
+  resting: {
+    text: {
+      B300: ['color.text.selected', 'color.text.link.resting', 'color.iconBorder.brand'],
+      B400: ['color.text.selected', 'color.text.link.resting', 'color.iconBorder.brand'],
+      R300: ['color.text.danger', 'color.iconBorder.danger'],
+      R400: ['color.text.danger', 'color.iconBorder.danger'],
+      Y300: ['color.text.warning', 'color.iconBorder.warning'],
+      Y400: ['color.text.warning', 'color.iconBorder.warning'],
+      P300: ['color.text.discovery', 'color.iconBorder.discovery'],
+      P400: ['color.text.discovery', 'color.iconBorder.discovery'],
+      G300: ['color.text.success', 'color.iconBorder.success'],
+      G400: ['color.text.success', 'color.iconBorder.success'],
+      N0: ['color.text.onBold'],
+      N70: ['color.text.lowEmphasis'],
+      N80: ['color.text.lowEmphasis'],
+      N90: ['color.text.lowEmphasis'],
+      N100: ['color.text.lowEmphasis'],
+      N200: ['color.text.lowEmphasis'],
+      N300: ['color.text.lowEmphasis'],
+      N400: ['color.text.mediumEmphasis'],
+      N500: ['color.text.mediumEmphasis'],
+      N600: ['color.text.mediumEmphasis'],
+      N700: ['color.text.highEmphasis'],
+      N800: ['color.text.highEmphasis'],
+      N900: ['color.text.highEmphasis']
+    },
+    background: {
+      B75: ['color.background.selected.resting'],
+      N40: ['color.background.subtleNeutral.resting', 'color.background.sunken'],
+      B50: ['color.background.subtleBrand.resting', 'color.background.selected.resting'],
+      Y75: ['color.background.subtleWarning.resting'],
+      P50: ['color.background.subtleDiscovery.resting'],
+      R50: ['color.background.subtleDanger.resting'],
+      G50: ['color.background.subtleSuccess.resting'],
+      P300: ['color.background.boldDiscovery.resting'],
+      P400: ['color.background.boldDiscovery.resting'],
+      G300: ['color.background.boldSuccess.resting'],
+      Y300: ['color.background.boldWarning.resting'],
+      Y500: ['color.background.boldWarning.resting'],
+      R400: ['color.background.boldDanger.resting'],
+      B400: ['color.background.boldBrand.resting'],
+      N0: ['color.background.default', 'color.background.overlay', 'color.background.card']
+    },
+    border: {
+      N10: ['color.border.neutral'],
+      N20: ['color.border.neutral'],
+      N30: ['color.border.neutral'],
+      N40: ['color.border.neutral'],
+      N50: ['color.border.neutral'],
+      N60: ['color.border.neutral'],
+      N70: ['color.border.neutral'],
+      B100: ['color.border.focus'],
+      B300: ['color.iconBorder.brand', 'color.text.selected'],
+      B400: ['color.iconBorder.brand', 'color.text.selected'],
+      R300: ['color.iconBorder.danger'],
+      R400: ['color.iconBorder.danger'],
+      Y300: ['color.iconBorder.warning'],
+      Y400: ['color.iconBorder.warning'],
+      P300: ['color.iconBorder.discovery'],
+      P400: ['color.iconBorder.discovery'],
+      G300: ['color.iconBorder.success'],
+      G400: ['color.iconBorder.success']
+    }
+  },
+  hover: {
+    text: {
+      B300: ['color.text.link.resting'],
+      B400: ['color.text.link.resting']
+    },
+    background: {
+      B50: ['color.background.selected.hover'],
+      B75: ['color.background.selected.hover'],
+      P200: ['color.background.boldDiscovery.hover'],
+      P300: ['color.background.boldDiscovery.hover'],
+      G200: ['color.background.boldSuccess.hover'],
+      R300: ['color.background.boldDanger.hover'],
+      Y200: ['color.background.boldWarning.hover'],
+      B300: ['color.background.boldBrand.hover']
+    },
+    border: {}
+  },
+  pressed: {
+    text: {
+      B300: ['color.text.link.pressed'],
+      B400: ['color.text.link.pressed']
+    },
+    background: {
+      B50: ['color.background.selected.pressed'],
+      B75: ['color.background.selected.pressed'],
+      P400: ['color.background.boldDiscovery.pressed'],
+      P500: ['color.background.boldDiscovery.pressed'],
+      G400: ['color.background.boldSuccess.pressed'],
+      R500: ['color.background.boldDanger.pressed'],
+      Y400: ['color.background.boldWarning.pressed'],
+      B500: ['color.background.boldBrand.pressed']
+    },
+    border: {}
+  },
+  disabled: {
+    text: {
+      N60: ['color.text.disabled'],
+      N70: ['color.text.disabled'],
+      N80: ['color.text.disabled'],
+      N90: ['color.text.disabled'],
+      N100: ['color.text.disabled']
+    },
+    background: {
+      N10: ['color.background.disabled'],
+      N20: ['color.background.disabled'],
+      N30: ['color.background.disabled'],
+      N40: ['color.background.disabled']
+    },
+    border: {
+      N10: ['color.background.disabled'],
+      N20: ['color.background.disabled'],
+      N30: ['color.background.disabled'],
+      N40: ['color.background.disabled']
+    }
+  }
+};
+var _default = colorMap;
+exports.default = _default;

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

@@ -0,0 +1,88 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = colorToToken;
+
+var _colorDifference = require("./color-difference");
+
+var _colorPaletteTokensMap = _interopRequireDefault(require("./color-palette-tokens-map"));
+
+function normalizeName(name) {
+  if (!name) {
+    return 'unknown';
+  }
+
+  if (name.startsWith('background')) {
+    return 'background';
+  }
+
+  if (name.toLowerCase().includes('color') || name === 'color' || name === 'fill' || name === 'stroke') {
+    return 'text';
+  }
+
+  if (name.startsWith('border') || name.toLowerCase().replace('-', '') === 'boxshadow') {
+    return 'border';
+  }
+
+  return 'unknown';
+}
+
+function colorToToken(paletteName, _ref) {
+  var _ref$state = _ref.state,
+      state = _ref$state === void 0 ? 'resting' : _ref$state,
+      propertyName = _ref.propertyName;
+  var getLowConfidenceFuzzyResult = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
+    return [];
+  };
+  var normalizedPropertyName = normalizeName(propertyName);
+  var value = paletteName.toUpperCase();
+  var tokenSuggestionProperties = _colorPaletteTokensMap.default[state];
+  var tokenSuggestionProperty = tokenSuggestionProperties && normalizedPropertyName !== 'unknown' && tokenSuggestionProperties[normalizedPropertyName];
+  var tokenSuggestionValue = tokenSuggestionProperty && tokenSuggestionProperty[value];
+
+  if (tokenSuggestionValue && tokenSuggestionValue.length === 1) {
+    return {
+      confidence: 'high',
+      suggestion: tokenSuggestionValue,
+      fallbackNeeded: true
+    };
+  }
+
+  if (tokenSuggestionValue && tokenSuggestionValue.length > 2) {
+    return {
+      confidence: 'medium',
+      suggestion: tokenSuggestionValue,
+      fallbackNeeded: true
+    };
+  }
+
+  var closestTokenName = (0, _colorDifference.findClosetMatchingToken)(value);
+
+  if (closestTokenName) {
+    return {
+      confidence: 'low',
+      suggestion: [closestTokenName],
+      fallbackNeeded: true
+    };
+  }
+
+  var fuzzyResult = getLowConfidenceFuzzyResult();
+
+  if (fuzzyResult.length) {
+    return {
+      confidence: 'low',
+      suggestion: fuzzyResult,
+      fallbackNeeded: true
+    };
+  }
+
+  return {
+    confidence: 'unknown',
+    suggestion: [],
+    fallbackNeeded: true
+  };
+}

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

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isLegacyNamedColor = exports.isLegacyColor = exports.isHardCodedColor = exports.includesHardCodedColor = void 0;
+
+var _legacyColors = require("./legacy-colors");
+
+var _namedColors = require("./named-colors");
+
+var isLegacyColor = function isLegacyColor(value) {
+  return _legacyColors.legacyColors.includes(value);
+};
+
+exports.isLegacyColor = isLegacyColor;
+
+var isLegacyNamedColor = function isLegacyNamedColor(value) {
+  return _legacyColors.legacyColorMixins.includes(value);
+};
+
+exports.isLegacyNamedColor = isLegacyNamedColor;
+
+var includesHardCodedColor = function includesHardCodedColor(raw) {
+  var 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 (var i = 0; i < _namedColors.namedColors.length; i++) {
+    if (value.includes("".concat(_namedColors.namedColors[i], ";"))) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+exports.includesHardCodedColor = includesHardCodedColor;
+
+var isHardCodedColor = function 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(')) {
+    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;
+};
+
+exports.isHardCodedColor = isHardCodedColor;

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,81 @@
+"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: ['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']
+};
+exports.legacyColorMetaMap = legacyColorMetaMap;