@atlaskit/codemod-cli 0.14.0 → 0.15.0

package/dist/cjs/presets/css-to-design-tokens/lib/value.js

@@ -0,0 +1,80 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseValue;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _colors = require("./colors");
+var _declaration = require("./declaration");
+var _meta = require("./meta");
+var _tokens = _interopRequireDefault(require("./tokens"));
+var _logger = require("./logger");
+function parseValue(value) {
+  if ((0, _colors.isLessFunction)(value)) {
+    _logger.logger.warn('Cannot parse - less function detected, would cause compilation error');
+    return null;
+  }
+  if ((0, _colors.isGradient)(value)) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var gradientContent = (0, _colors.extractBetweenParentheses)(value);
+        var values = gradientContent.split(',');
+        var replacedValues = values.map(function (val) {
+          var parsedValue = parseValue(val.trim());
+          return parsedValue ? parsedValue.getReplacement(additionalMeta) : val;
+        });
+        return value.replace(gradientContent, replacedValues.join(', '));
+      },
+      getMeta: function getMeta() {
+        var BASE_META = [];
+        var gradientContent = (0, _colors.extractBetweenParentheses)(value);
+        var values = gradientContent.split(',');
+        var metas = values.reduce(function (acc, val) {
+          var parsedValue = parseValue(val.trim());
+          return parsedValue ? [].concat((0, _toConsumableArray2.default)(acc), (0, _toConsumableArray2.default)(parsedValue.getMeta())) : acc;
+        }, BASE_META);
+        return metas;
+      }
+    };
+  }
+  if ((0, _colors.isKnownCssVariable)((0, _declaration.extractCssVarName)(value))) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var token = (0, _tokens.default)([].concat((0, _toConsumableArray2.default)(additionalMeta), (0, _toConsumableArray2.default)(this.getMeta())));
+        return "var(".concat(token, ", ").concat(value, ")");
+      },
+      getMeta: function getMeta() {
+        return (0, _meta.getCssVarMeta)(value);
+      }
+    };
+  }
+  if ((0, _colors.isRawColor)(value)) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var token = (0, _tokens.default)([].concat((0, _toConsumableArray2.default)(additionalMeta), (0, _toConsumableArray2.default)(this.getMeta())));
+        return "var(".concat(token, ", ").concat(value, ")");
+      },
+      getMeta: function getMeta() {
+        return (0, _meta.getRawColorMeta)(value);
+      }
+    };
+  }
+  if ((0, _colors.isNamedColor)(value)) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var token = (0, _tokens.default)([].concat((0, _toConsumableArray2.default)(additionalMeta), (0, _toConsumableArray2.default)(this.getMeta())));
+        return "var(".concat(token, ", ").concat(value, ")");
+      },
+      getMeta: function getMeta() {
+        return (0, _meta.getNamedColorMeta)(value);
+      }
+    };
+  }
+  return null;
+}

package/dist/cjs/presets/index.js

@@ -18,5 +18,4 @@ require("./css-to-design-tokens/css-to-design-tokens");
 var presets = ['styled-to-emotion', 'theme-to-design-tokens', 'theme-remove-deprecated-mixins', 'css-to-design-tokens'].map(function (preset) {
   return _path.default.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
-var _default = presets;
-exports.default = _default;
+var _default = exports.default = presets;

package/dist/cjs/presets/styled-to-emotion/styled-to-emotion.js

@@ -46,5 +46,4 @@ function transformer(fileInfo, _ref, options) {
   });
   return source;
 }
-var parser = 'tsx';
-exports.parser = parser;
+var parser = exports.parser = 'tsx';

package/dist/cjs/presets/theme-remove-deprecated-mixins/utils/replacements.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.colorReplacements = void 0;
-var colorReplacements = {
+var colorReplacements = exports.colorReplacements = {
   background: {
     fullReplacement: "themed({ light: token('elevation.surface', N0), dark: token('elevation.surface', DN30) })",
     staticReplacement: 'N0',
@@ -142,5 +142,4 @@ var colorReplacements = {
     tokenId: 'color.skeleton',
     importSpecifiers: ['N20A']
   }
-};
-exports.colorReplacements = colorReplacements;
+};

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

@@ -337,8 +337,8 @@ function _transformer() {
 
           // JSX props
           source.find(j.JSXAttribute).forEach(function (path) {
-            var _path$value, _path$value$value;
-            if (((_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.type) !== 'JSXExpressionContainer') {
+            var _path$value;
+            if (((_path$value = path.value) === null || _path$value === void 0 || (_path$value = _path$value.value) === null || _path$value === void 0 ? void 0 : _path$value.type) !== 'JSXExpressionContainer') {
               return;
             }
             if ((0, _ast.isParentOfToken)(j, path)) {

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

@@ -8,16 +8,14 @@ exports.isBoldColor = isBoldColor;
 exports.isLegacyNamedColor = exports.isLegacyColor = exports.isHardCodedColor = void 0;
 var _legacyColors = require("./legacy-colors");
 var _namedColors = require("./named-colors");
-var isLegacyColor = function isLegacyColor(value) {
+var isLegacyColor = exports.isLegacyColor = function isLegacyColor(value) {
   return _legacyColors.legacyColors.includes(value);
 };
-exports.isLegacyColor = isLegacyColor;
-var isLegacyNamedColor = function isLegacyNamedColor(value) {
+var isLegacyNamedColor = exports.isLegacyNamedColor = function isLegacyNamedColor(value) {
   return _legacyColors.legacyColorMixins.includes(value);
 };
-exports.isLegacyNamedColor = isLegacyNamedColor;
 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 includesHardCodedColor = exports.includesHardCodedColor = function includesHardCodedColor(raw) {
   var value = raw.toLowerCase();
   if (colorRegexp.exec(value)) {
     return true;
@@ -29,8 +27,7 @@ var includesHardCodedColor = function includesHardCodedColor(raw) {
   }
   return false;
 };
-exports.includesHardCodedColor = includesHardCodedColor;
-var isHardCodedColor = function isHardCodedColor(raw) {
+var isHardCodedColor = exports.isHardCodedColor = function isHardCodedColor(raw) {
   var value = raw.toLowerCase();
   if (_namedColors.namedColors.includes(value)) {
     return true;
@@ -41,7 +38,6 @@ var isHardCodedColor = function isHardCodedColor(raw) {
   }
   return false;
 };
-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

@@ -5,12 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.containsReplaceableCSSDeclarations = containsReplaceableCSSDeclarations;
 exports.findEndIndexOfCSSExpression = findEndIndexOfCSSExpression;
-var _cssToDesignTokens = require("../../css-to-design-tokens/css-to-design-tokens");
+var _declaration = require("../../css-to-design-tokens/lib/declaration");
 function containsReplaceableCSSDeclarations(input) {
   var cssPattern = /(\S+)\s*:/g;
   var match;
   while ((match = cssPattern.exec(input)) !== null) {
-    if ((0, _cssToDesignTokens.isColorProperty)(match[1])) {
+    if ((0, _declaration.isColorRelatedProperty)(match[1])) {
       return true;
     }
   }

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

@@ -286,5 +286,4 @@ var FuzzySet = function FuzzySet() {
   }
   return fuzzyset;
 };
-var _default = FuzzySet;
-exports.default = _default;
+var _default = exports.default = FuzzySet;

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

@@ -4,11 +4,9 @@ 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 = {
+var legacyColors = exports.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 legacyColorMixins = exports.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 legacyColorMetaMap = exports.legacyColorMetaMap = {
   R50: ['danger'],
   R75: ['danger'],
   R100: ['danger'],
@@ -95,5 +93,4 @@ var legacyColorMetaMap = {
   grey: ['background', 'neutral'],
   skeleton: ['skeleton'],
   white: ['inverse']
-};
-exports.legacyColorMetaMap = legacyColorMetaMap;
+};

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

@@ -4,5 +4,4 @@ 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;
+var namedColors = exports.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/cjs/presets/theme-to-design-tokens/utils/string-utils.js

@@ -6,12 +6,11 @@ Object.defineProperty(exports, "__esModule", {
 exports.findFirstNonspaceIndexAfter = findFirstNonspaceIndexAfter;
 exports.kebabize = void 0;
 exports.splitAtIndex = splitAtIndex;
-var kebabize = function kebabize(str) {
+var kebabize = exports.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/);

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

@@ -7,15 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.tokens = exports.getUniqueWordsFromTokens = void 0;
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _tokensRaw = require("@atlaskit/tokens/tokens-raw");
-var tokens = _tokensRaw.light.filter(function (t) {
+var tokens = exports.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;
-var getUniqueWordsFromTokens = tokens.reduce(function (accum, val) {
+var getUniqueWordsFromTokens = exports.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) {
@@ -26,5 +25,4 @@ var getUniqueWordsFromTokens = tokens.reduce(function (accum, val) {
     accum.push(val);
   }
   return accum;
-}, []);
-exports.getUniqueWordsFromTokens = getUniqueWordsFromTokens;
+}, []);

package/dist/cjs/sinceRef.js

@@ -26,7 +26,7 @@ var parseDiffLine = function parseDiffLine(line) {
 /** Returns packages that have been upgraded in package.json since ref. The version refers to their previous
  * version
  */
-var getPackagesSinceRef = /*#__PURE__*/function () {
+var getPackagesSinceRef = exports.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) {
@@ -85,7 +85,6 @@ var getPackagesSinceRef = /*#__PURE__*/function () {
     return _ref.apply(this, arguments);
   };
 }();
-exports.getPackagesSinceRef = getPackagesSinceRef;
 if (require.main === module) {
   // eslint-disable-next-line no-console
   getPackagesSinceRef(process.argv[2]).then(function (res) {

package/dist/cjs/transforms.js

@@ -16,13 +16,12 @@ var basePath = function basePath(packages) {
   }).join(','), ",}")] : ['@{atlaskit,atlassian,atlassiansox}', '*'];
   return _path.default.join.apply(_path.default, [process.cwd(), 'node_modules'].concat(packageDirectory, ['codemods']));
 };
-var hasTransform = function hasTransform(transformPath) {
+var hasTransform = exports.hasTransform = function hasTransform(transformPath) {
   return _glob.default.sync(transformPath).length > 0;
 };
 
 /** Retrieves transforms for `packages` if provided, otherwise all transforms including presets */
-exports.hasTransform = hasTransform;
-var getTransforms = function getTransforms(packages) {
+var getTransforms = exports.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.apply(transforms, (0, _toConsumableArray2.default)(_presets.default));
@@ -35,25 +34,21 @@ var getTransforms = function getTransforms(packages) {
     return parseTransformPath(transform);
   }).filter(filterTransforms(packages)).sort();
 };
-exports.getTransforms = getTransforms;
-var parseTransformPath = function parseTransformPath(transformPath) {
+var parseTransformPath = exports.parseTransformPath = function parseTransformPath(transformPath) {
   return _path.default.parse(transformPath);
 };
-exports.parseTransformPath = parseTransformPath;
-var getTransformPath = function getTransformPath(_ref) {
+var getTransformPath = exports.getTransformPath = function getTransformPath(_ref) {
   var dir = _ref.dir,
     base = _ref.base;
   return "".concat(dir, "/").concat(base);
 };
-exports.getTransformPath = getTransformPath;
-var getTransformModule = function getTransformModule(transform) {
+var getTransformModule = exports.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;
-var getTransformVersion = function getTransformVersion(transform) {
+var getTransformVersion = exports.getTransformVersion = function getTransformVersion(transform) {
   var transformName = transform.base;
   if (transformName.startsWith('index.')) {
     var pathSegments = transform.dir.split(_path.default.sep);
@@ -61,7 +56,6 @@ var getTransformVersion = function getTransformVersion(transform) {
   }
   return transformName.split('-')[0];
 };
-exports.getTransformVersion = getTransformVersion;
 var filterTransforms = function filterTransforms(packages) {
   if (!packages || packages.length === 0) {
     return function () {

package/dist/cjs/types.js

@@ -16,7 +16,7 @@ function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Re
 /** Converts required args to optional if they have a default
  * Example: export type UserFlags = Default<Flags, keyof typeof defaultFlags>;
  */
-var ValidationError = /*#__PURE__*/function (_Error) {
+var ValidationError = exports.ValidationError = /*#__PURE__*/function (_Error) {
   (0, _inherits2.default)(ValidationError, _Error);
   var _super = _createSuper(ValidationError);
   function ValidationError() {
@@ -25,8 +25,7 @@ var ValidationError = /*#__PURE__*/function (_Error) {
   }
   return (0, _createClass2.default)(ValidationError);
 }( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
-exports.ValidationError = ValidationError;
-var NoTransformsExistError = /*#__PURE__*/function (_Error2) {
+var NoTransformsExistError = exports.NoTransformsExistError = /*#__PURE__*/function (_Error2) {
   (0, _inherits2.default)(NoTransformsExistError, _Error2);
   var _super2 = _createSuper(NoTransformsExistError);
   function NoTransformsExistError() {
@@ -34,5 +33,4 @@ var NoTransformsExistError = /*#__PURE__*/function (_Error2) {
     return _super2.apply(this, arguments);
   }
   return (0, _createClass2.default)(NoTransformsExistError);
-}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));
-exports.NoTransformsExistError = NoTransformsExistError;
+}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error));

package/dist/cjs/utils.js

@@ -36,7 +36,7 @@ var getLineEndingRegex = function getLineEndingRegex(type) {
     return '\r\n';
   }
 };
-var fixLineEnding = function fixLineEnding(source, lineEnding) {
+var fixLineEnding = exports.fixLineEnding = function fixLineEnding(source, lineEnding) {
   var current = returnLineEnding(source);
   if (current === lineEnding) {
     return source;
@@ -47,5 +47,4 @@ var fixLineEnding = function fixLineEnding(source, lineEnding) {
     return source.replace(new RegExp(regexCurrentLineEnding, 'g'), regexLineEnding);
   }
   return source;
-};
-exports.fixLineEnding = fixLineEnding;
+};

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

@@ -1,71 +1,14 @@
 import postcss from 'postcss';
 // @ts-ignore
 import lessSyntax from 'postcss-less';
-import { light as rawTokens } from '@atlaskit/tokens/tokens-raw';
-import designTokens from '@atlaskit/tokens/token-names';
-import Search from '../theme-to-design-tokens/utils/fuzzy-search';
-import { knownVariables, knownColors, knownRawColors } from './utils/legacy-colors';
-import { cleanMeta } from './utils/meta';
-const options = {
+import { isColorRelatedProperty, isCssDeclaration, splitCssValue } from './lib/declaration';
+import { getBaseDeclarationMeta } from './lib/meta';
+import findToken from './lib/tokens';
+import parseValue from './lib/value';
+const POSTCSS_OPTIONS = {
   syntax: lessSyntax,
   from: undefined
 };
-const tokens = rawTokens.filter(t => t.attributes.state === 'active').map(t => t.name.replace(/\.\[default\]/g, '')).filter(t => !t.includes('UNSAFE') && !t.includes('interaction'));
-const search = Search(tokens, false);
-function isRule(node) {
-  return node.type === 'rule';
-}
-function getParentSelectors(node) {
-  if (isRule(node)) {
-    // @ts-expect-error
-    return getParentSelectors(node.parent) + ' ' + node.selector;
-  }
-  if (node.parent) {
-    return getParentSelectors(node.parent);
-  }
-  return '';
-}
-function stripVar(prop) {
-  return prop.substring(prop.indexOf('(') + 1).split(/\,|\)/)[0];
-}
-function stripLessVar(prop) {
-  return prop.substring(1);
-}
-export function isColorProperty(prop) {
-  return prop === 'color' || prop === 'background' || prop === 'background-color' || prop === 'box-shadow' || prop === 'border' || prop === 'border-left' || prop === 'border-right' || prop === 'border-top' || prop === 'border-bottom' || prop === 'border-color' || prop === 'outline';
-}
-function getDeclarationMeta(decl) {
-  if (decl.prop === 'color') {
-    return 'text';
-  }
-  if (decl.prop.startsWith('background')) {
-    return 'background';
-  }
-  if (decl.prop.includes('shadow')) {
-    return 'shadow';
-  }
-  if (decl.prop.includes('border')) {
-    return 'border';
-  }
-  return '';
-}
-function isDesignToken(tokenName) {
-  return Boolean(Object.entries(designTokens).find(([_, value]) => tokenName === value));
-}
-function getMetaFromCssVar(tokenName) {
-  const meta = knownVariables[tokenName];
-  if (!meta || meta.length === 0) {
-    return tokenName.split('-');
-  }
-  return meta;
-}
-function getMetaFromRawColor(rawColor) {
-  let cleanColor = rawColor.toLowerCase();
-  if (cleanColor.length === 4) {
-    cleanColor = cleanColor + cleanColor.substring(cleanColor.indexOf('#') + 1);
-  }
-  return knownRawColors[cleanColor];
-}
 
 // https://github.com/postcss/postcss/blob/main/docs/writing-a-plugin.md
 // https://astexplorer.net/#/2uBU1BLuJ1
@@ -73,69 +16,62 @@ const plugin = () => {
   const processed = Symbol('processed');
   return {
     postcssPlugin: 'UsingTokens',
-    Declaration: decl => {
+    AtRule(atRule, helper) {
       // @ts-expect-error
-      if (decl[processed]) {
+      if (atRule[processed]) {
         return;
       }
-      if (!isColorProperty(decl.prop)) {
+
+      // @ts-expect-error: The 'variable' property does not exist on 'AtRule' according to the TypeScript definitions.
+      // However, the 'postcss-less' library adds a 'variable' property to 'AtRule' when parsing LESS variables.
+      // This property indicates whether the 'AtRule' is a LESS variable.
+      if (atRule.variable) {
+        // TODO https://hello.atlassian.net/browse/DCA11Y-637
+      }
+
+      // @ts-expect-error
+      atRule[processed] = true;
+    },
+    Declaration: decl => {
+      // @ts-expect-error
+      if (decl[processed]) {
         return;
       }
       if (decl.value === 'none') {
         return;
       }
-      const searchTerms = [getDeclarationMeta(decl), ...getParentSelectors(decl).split(/\-|\.|\,|\ |\:|\&/).filter(el => !!el)];
-      let match;
-      const cssVarRe = /var\([^\)]+\)/g;
-      const lessVarRe = /@[a-zA-Z0-9-]+/g;
-      const rawColorRe = /(#([0-9a-f]{3}){1,2}|(rgba|hsla)\(\d{1,3}%?(,\s?\d{1,3}%?){2},\s?(1|0|0?\.\d+)\)|(rgb|hsl)\(\d{1,3}%?(,\s?\d{1,3}%?){2}\))/i;
-
-      // CSS variables
-      const cssVarMatch = decl.value.match(cssVarRe);
-      if (cssVarMatch) {
-        var _getMetaFromCssVar;
-        match = cssVarMatch[0];
-        if (isDesignToken(stripVar(match))) {
+      const baseMeta = getBaseDeclarationMeta(decl);
+      if (isCssDeclaration(decl.prop)) {
+        // TODO https://hello.atlassian.net/browse/DCA11Y-637
+      }
+      if (isColorRelatedProperty(decl.prop)) {
+        const values = splitCssValue(decl.value);
+        if (!values) {
           return;
         }
-        searchTerms.push(...((_getMetaFromCssVar = getMetaFromCssVar(stripVar(match))) !== null && _getMetaFromCssVar !== void 0 ? _getMetaFromCssVar : []));
-      }
-
-      // Less variables
-      const lessVarMatch = decl.value.match(lessVarRe);
-      if (lessVarMatch) {
-        var _getMetaFromCssVar2;
-        match = lessVarMatch[0];
-        searchTerms.push(...((_getMetaFromCssVar2 = getMetaFromCssVar(`--${stripLessVar(match)}`)) !== null && _getMetaFromCssVar2 !== void 0 ? _getMetaFromCssVar2 : []));
-      }
-
-      // Raw colors
-      const rawColorMatch = decl.value.match(rawColorRe);
-      if (rawColorMatch) {
-        var _getMetaFromRawColor;
-        match = rawColorMatch[0];
-        searchTerms.push(...((_getMetaFromRawColor = getMetaFromRawColor(match)) !== null && _getMetaFromRawColor !== void 0 ? _getMetaFromRawColor : []));
-      }
-
-      // Named colors
-      if (knownColors.hasOwnProperty(decl.value)) {
-        var _knownColors$decl$val;
-        match = decl.value;
-        searchTerms.push(...((_knownColors$decl$val = knownColors[decl.value.toLowerCase()]) !== null && _knownColors$decl$val !== void 0 ? _knownColors$decl$val : []));
-      }
-      if (!match) {
-        // eslint-disable-next-line no-console
-        console.warn(`Unable to find match for declaration: ${decl.prop}: ${decl.value}`);
-        return;
-      }
-      const cleanSearchTerms = cleanMeta(searchTerms).join(' ');
-      const results = search.get(cleanSearchTerms);
-      const candidates = results.map(result => result[1]);
-      const replacement = candidates.length ? designTokens[candidates[0]] : 'MISSING_TOKEN';
-      if (decl.prop === 'box-shadow') {
-        decl.value = `var(${replacement}, ${decl.value})`;
-      } else {
-        decl.value = decl.value.split(match).join(`var(${replacement}, ${match})`);
+        switch (decl.prop) {
+          case 'box-shadow':
+            const meta = values.reduce((acc, curr) => {
+              const parsedValue = parseValue(curr);
+              if (!parsedValue) {
+                return acc;
+              }
+              return [...acc, ...parsedValue.getMeta()];
+            }, baseMeta);
+            const token = findToken(meta);
+            decl.value = `var(${token}, ${decl.value})`;
+            break;
+          default:
+            const replacedValues = values.map(value => {
+              const parsedValue = parseValue(value);
+              if (!parsedValue) {
+                return value;
+              }
+              return parsedValue.getReplacement(baseMeta);
+            });
+            decl.value = replacedValues.join(' ');
+            break;
+        }
       }
 
       // @ts-expect-error
@@ -148,6 +84,6 @@ export default async function transformer(file) {
   const src = typeof file === 'string' ? file : file.source;
   const {
     css
-  } = await processor.process(src, options);
+  } = await processor.process(src, POSTCSS_OPTIONS);
   return css;
 }

package/dist/es2019/presets/css-to-design-tokens/lib/colors.js

@@ -0,0 +1,34 @@
+import { knownNamedColors, knownVariables } from './legacy-colors';
+const NAMED_COLORS = Object.keys(knownNamedColors);
+const GRADIENT_TYPES = ['linear', 'radial', 'conic'];
+const LESS_COLOR_FUNCTIONS = ['lighten', 'darken', 'saturate', 'desaturate', 'fadein', 'fadeout', 'fade', 'spin', 'mix', 'greyscale', 'contrast', 'multiply', 'screen', 'overlay', 'softlight', 'hardlight', 'difference', 'exclusion', 'average', 'negation', 'tint', 'shade', 'luma', 'hue', 'saturation', 'lightness', 'alpha', 'red', 'green', 'blue'];
+const REGEXES = {
+  // The CSS regular expression matches CSS variable declarations.
+  // It looks for the string "var(" followed by any characters except a closing parenthesis, and ending with a closing parenthesis.
+  CSS: /var\([^\)]+\)/g,
+  // The RAW_COLOR regular expression matches various CSS color formats including hexadecimal, RGB(A), HSL(A), LAB, LCH, and HWB.
+  // It allows for optional leading and trailing white spaces.
+  // For RGBA and HSLA, it allows any number (including negative numbers and numbers greater than 1) for the alpha channel.
+  // For RGB, HSL, LAB, LCH, and HWB, it expects three comma-separated values.
+  // It also allows optional white spaces around the commas and the values.
+  RAW_COLOR: /^\s*(#([0-9a-f]{3}){1,2}|(rgba|hsla)\(\s*\d{1,3}%?\s*(,\s*\d{1,3}%?\s*){2},\s*-?\d*\.?\d+\s*\)|(rgb|hsl)\(\s*\d{1,3}%?\s*(,\s*\d{1,3}%?\s*){2}\)\s*|(lab|lch)\(\s*\d{1,3}%?\s+\d{1,3}%?\s+\d{1,3}%?\s*\)|hwb\(\s*\d{1,3}\s+\d{1,3}%?\s+\d{1,3}%?\s*\))\s*$/i
+};
+export function isKnownCssVariable(value) {
+  return value in knownVariables;
+}
+export function isRawColor(value) {
+  return REGEXES.RAW_COLOR.test(value);
+}
+export function isNamedColor(value) {
+  return NAMED_COLORS.includes(value);
+}
+export function isGradient(value) {
+  return GRADIENT_TYPES.some(gradient => value.startsWith(`${gradient}-gradient(`));
+}
+export function extractBetweenParentheses(value) {
+  const match = value.match(/\((.*?)\)/);
+  return match ? match[1] : '';
+}
+export function isLessFunction(value) {
+  return LESS_COLOR_FUNCTIONS.some(func => value.startsWith(`${func}(`));
+}