@atlaskit/codemod-cli 0.13.4 → 0.15.0

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

@@ -1,22 +1,22 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
 /* eslint-disable no-console */
 
 import { isDecendantOfType, hasImportDeclaration } from '@codeshift/utils';
 import { isDecendantOfToken, isParentOfToken } from './utils/ast';
 import { cleanMeta, getMetaFromAncestors } from './utils/ast-meta';
-import { includesHardCodedColor, isHardCodedColor, isLegacyColor, isLegacyNamedColor } from './utils/color';
+import { includesHardCodedColor, isHardCodedColor, isLegacyColor, isLegacyNamedColor, isBoldColor } from './utils/color';
 import Search from './utils/fuzzy-search';
 import { legacyColorMetaMap } from './utils/legacy-colors';
 import { tokens } from './utils/tokens';
-var kebabize = function kebabize(str) {
-  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, function ($, ofs) {
-    return (ofs ? '-' : '') + $.toLowerCase();
-  });
-};
-function isBoldColor(color) {
-  var number = parseInt(color.replace(/^./, ''), 10);
-  return number > 300;
-}
+import { kebabize, findFirstNonspaceIndexAfter, splitAtIndex } from './utils/string-utils';
+import { containsReplaceableCSSDeclarations, findEndIndexOfCSSExpression } from './utils/css-utils';
+import CSSTransformer from '../css-to-design-tokens/css-to-design-tokens';
 function insertTokenImport(j, source) {
   if (hasImportDeclaration(j, source, '@atlaskit/tokens')) {
     return;
@@ -28,6 +28,24 @@ function buildToken(j, tokenId, node) {
   var callExpr = j.callExpression(j.identifier('token'), [j.stringLiteral(tokenId), node].filter(Boolean));
   return callExpr;
 }
+
+// Wrap over the j.templateElement builder to provide a more convenient API.
+function buildTemplateElement(j, text) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    tail: false,
+    fromNode: null
+  };
+  var tail;
+  if (options.fromNode) {
+    tail = options.fromNode.tail;
+  } else {
+    tail = !!options.tail;
+  }
+  return j.templateElement({
+    raw: text,
+    cooked: null
+  }, tail);
+}
 function getColorFromIdentifier(expression) {
   var value = '';
   if (expression.type === 'Identifier') {
@@ -139,100 +157,328 @@ function getTokenFromNode(j, path, value, propertyName) {
 }
 function parseCSSPropertyName(cssString) {
   var lastColonIndex = cssString.lastIndexOf(':');
-  var propertyNameEndIndex = Math.max(cssString.lastIndexOf(';', lastColonIndex), cssString.lastIndexOf(' ', lastColonIndex));
-  return cssString.slice(propertyNameEndIndex + 1, lastColonIndex).trim();
+  if (lastColonIndex === -1) {
+    return {
+      colonIndex: null,
+      cssPropertyName: null
+    };
+  }
+  var propertyNameEndIndex = Math.max(cssString.lastIndexOf(';', lastColonIndex), cssString.lastIndexOf(' ', lastColonIndex), -1);
+  var startIndex = propertyNameEndIndex + 1;
+  return {
+    cssPropertyName: cssString.slice(startIndex, lastColonIndex).trim(),
+    colonIndex: lastColonIndex
+  };
+}
+export default function transformer(_x, _x2) {
+  return _transformer.apply(this, arguments);
 }
-export default function transformer(file, api) {
-  var debug = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  var j = api.jscodeshift;
-  var source = j(file.source);
-  var transformed = false;
+function _transformer() {
+  _transformer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(file, api) {
+    var debug,
+      j,
+      source,
+      transformed,
+      templateLiteralPaths,
+      _iterator,
+      _step,
+      _loop,
+      replaceStringLiteralIfItConsistsOnlyOfColor,
+      replaceTemplateLiteralExpression,
+      _args2 = arguments;
+    return _regeneratorRuntime.wrap(function _callee$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          replaceTemplateLiteralExpression = function _replaceTemplateLiter(j, mainPath, expressionPath, expressionIndex) {
+            var expression = expressionPath.value;
+            if (!(expression.type === 'MemberExpression' || expression.type === 'Identifier')) {
+              return false;
+            }
+            if (isDecendantOfToken(j, expressionPath)) {
+              return false;
+            }
+            var value = getColorFromIdentifier(expression);
+            if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
+              return false;
+            }
+            var precedingQuasi = mainPath.value.quasis[expressionIndex];
+            var precedingQuasiText = precedingQuasi.value.raw;
+            var _parseCSSPropertyName = parseCSSPropertyName(precedingQuasiText),
+              cssPropertyName = _parseCSSPropertyName.cssPropertyName,
+              colonIndex = _parseCSSPropertyName.colonIndex;
+            if (!cssPropertyName) {
+              return false;
+            }
+            var tokenId = getTokenFromNode(j, expressionPath, value, cssPropertyName);
+            insertTokenImport(j, source);
+            var newQuasis = _toConsumableArray(mainPath.value.quasis);
+            var newExpressions = _toConsumableArray(mainPath.value.expressions);
+            if (cssPropertyName !== 'box-shadow') {
+              var tokenExpression = buildToken(j, tokenId, expressionPath.value);
+              newExpressions[expressionIndex] = tokenExpression;
+            } else {
+              // box-shadow is a multi-part property where the color can appear at any
+              // part position (even though the standard suggests that color comes
+              // last, browsers' CSS parsers are more lax). If we get here, then the
+              // color part is replaceable.  Textually, it's something like:
+              //
+              // <rules before>; box-shadow: 0 1px ${colors.N50} 2rem; <rules after>
+              //
+              // the fallback value will be multipart, i.e. the token call is
+              //
+              // token(<replacedValue>, `0 1px ${colors.N50} 2rem`)
+              //
+              // and it's wrapped in a substitution like this:
+              //
+              // <rules before>; box-shadow: ${token(<...>)}; <rules after>
+              //
+              // We stich the fallback from the last part of preceding quasi (after
+              // colon) and the first part of the following quasi (before ';' or '}').
+              //
+              // If multiple box-shadows are comma-separated but only one of them has a
+              // replaceable color and others are hard-coded, this logic would still
+              // work. When multiple shadows have expressions, it's unfortunately not
+              // possible to proceed because we cannot find where the value ends from a
+              // single following quasi.
+              var valueStartIndex = findFirstNonspaceIndexAfter(precedingQuasiText, colonIndex);
+              var _splitAtIndex = splitAtIndex(precedingQuasiText, valueStartIndex),
+                _splitAtIndex2 = _slicedToArray(_splitAtIndex, 2),
+                newPrecedingQuasiText = _splitAtIndex2[0],
+                partialValueBeginning = _splitAtIndex2[1];
+              var followingQuasi = mainPath.value.quasis[expressionIndex + 1];
+              var followingQuasiText = followingQuasi.value.raw;
+              var valueEndIndex = findEndIndexOfCSSExpression(followingQuasiText, followingQuasi.tail);
+              if (!valueEndIndex) {
+                console.warn('cannot find end of box-shadow value, please check manually');
+                return false;
+              }
+              var _splitAtIndex3 = splitAtIndex(followingQuasiText, valueEndIndex + 1),
+                _splitAtIndex4 = _slicedToArray(_splitAtIndex3, 2),
+                partialValueEnd = _splitAtIndex4[0],
+                newFollowingQuasiText = _splitAtIndex4[1];
+              var internalQuasis = [buildTemplateElement(j, partialValueBeginning, {
+                tail: false
+              }), buildTemplateElement(j, partialValueEnd, {
+                tail: true
+              })];
+              var internalExpressions = [expressionPath.value];
+              var newFallback = j.templateLiteral(internalQuasis, internalExpressions);
+              var newExpression = buildToken(j, tokenId, newFallback);
+              newQuasis[expressionIndex] = buildTemplateElement(j, newPrecedingQuasiText, {
+                fromNode: newQuasis[expressionIndex]
+              });
+              newExpressions[expressionIndex] = newExpression;
+              newQuasis[expressionIndex + 1] = buildTemplateElement(j, newFollowingQuasiText, {
+                fromNode: newQuasis[expressionIndex]
+              });
+            }
+            mainPath.replace(j.templateLiteral(newQuasis, newExpressions));
+            return true;
+          };
+          replaceStringLiteralIfItConsistsOnlyOfColor = function _replaceStringLiteral(j, path, value) {
+            if (isDecendantOfToken(j, path)) {
+              return false;
+            }
+            if (isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
+              var parent = path.parent.value;
+              var key = '';
+              if (parent.type === 'VariableDeclarator') {
+                key = parent.id.name;
+              }
+              var tokenId = getTokenFromNode(j, path, value, key);
+              insertTokenImport(j, source);
+              j(path).replaceWith(buildToken(j, tokenId, path.value));
+              return true;
+            }
+            return false;
+          };
+          debug = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : false;
+          j = api.jscodeshift;
+          source = j(file.source);
+          transformed = false; // Objects
+          source.find(j.ObjectProperty).forEach(function (path) {
+            if (path.value.value.type === 'ObjectExpression') {
+              return;
+            }
 
-  // Objects
-  source.find(j.ObjectProperty).forEach(function (path) {
-    if (path.value.value.type === 'ObjectExpression') {
-      return;
-    }
+            // Avoid transforming objects that are default arguments
+            if (path.parent.parent.value.type === 'ArrowFunctionExpression' || path.parent.parent.value.type === 'FunctionDeclaration') {
+              return;
+            }
+            if (isParentOfToken(j, path.value.value)) {
+              return;
+            }
+            var value = getColorFromIdentifier(path.value.value);
+            if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
+              return;
+            }
+            var key;
+            if (path.value.key.type === 'NumericLiteral' || path.value.key.type === 'StringLiteral') {
+              key = path.value.key.value.toString();
+            }
+            if (path.value.key.type === 'Identifier') {
+              key = path.value.key.name;
+            }
 
-    // Avoid transforming objects that are default arguments
-    if (path.parent.parent.value.type === 'ArrowFunctionExpression' || path.parent.parent.value.type === 'FunctionDeclaration') {
-      return;
-    }
-    if (isParentOfToken(j, path.value.value)) {
-      return;
-    }
-    var value = getColorFromIdentifier(path.value.value);
-    if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
-      return;
-    }
-    var key;
-    if (path.value.key.type === 'NumericLiteral' || path.value.key.type === 'StringLiteral') {
-      key = path.value.key.value.toString();
-    }
-    if (path.value.key.type === 'Identifier') {
-      key = path.value.key.name;
-    }
+            // Key is a node type we do not support
+            if (!key) {
+              return;
+            }
+            var tokenId = getTokenFromNode(j, path, value, key);
+            insertTokenImport(j, source);
+            j(path).replaceWith(j.objectProperty(path.value.key, buildToken(j, tokenId, path.value.value)));
+            transformed = true;
+          });
 
-    // Key is a node type we do not support
-    if (!key) {
-      return;
-    }
-    var tokenId = getTokenFromNode(j, path, value, key);
-    insertTokenImport(j, source);
-    j(path).replaceWith(j.objectProperty(path.value.key, buildToken(j, tokenId, path.value.value)));
-    transformed = true;
-  });
+          // JSX props
+          source.find(j.JSXAttribute).forEach(function (path) {
+            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 (isParentOfToken(j, path)) {
+              return;
+            }
+            var expression = path.value.value.expression;
+            var value = getColorFromIdentifier(expression);
+            if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
+              return;
+            }
+            var tokenId = getTokenFromNode(j, path, value, path.value.name.name);
+            insertTokenImport(j, source);
+            j(path).find(j.JSXExpressionContainer).forEach(function (path) {
+              var tokenNode = buildToken(j, tokenId, path.value.expression);
+              j(path).replaceWith(j.jsxExpressionContainer(tokenNode));
+            });
+            transformed = true;
+          });
 
-  // Template literals
-  source.find(j.TemplateLiteral).forEach(function (path) {
-    function replaceTemplateLiteralExpressions(j, expression, index) {
-      if (isDecendantOfToken(j, expression)) {
-        return;
-      }
-      if (index >= path.value.quasis.length) {
-        return;
-      }
-      var quasi = path.value.quasis[index];
-      var value = getColorFromIdentifier(expression.value);
-      if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
-        return;
-      }
-      var tokenId = getTokenFromNode(j, expression, value, parseCSSPropertyName(quasi.value.cooked || ''));
-      insertTokenImport(j, source);
-      expression.replace(buildToken(j, tokenId, expression.value));
-    }
-    j(path).find(j.Identifier).filter(function (expression) {
-      return !isDecendantOfType(j, expression, j.MemberExpression);
-    }).forEach(function (expression, i) {
-      return replaceTemplateLiteralExpressions(j, expression, i);
-    });
-    j(path).find(j.MemberExpression).forEach(function (expression, i) {
-      return replaceTemplateLiteralExpressions(j, expression, i);
-    });
-    transformed = true;
-  });
+          // Strings
+          source.find(j.StringLiteral).forEach(function (path) {
+            j(path).filter(function (expression) {
+              return !isDecendantOfType(j, expression, j.ObjectExpression);
+            }).forEach(function (path) {
+              var value = path.value.value;
+              if (replaceStringLiteralIfItConsistsOnlyOfColor(j, path, value)) {
+                transformed = true;
+              }
+            });
+          });
+          templateLiteralPaths = source.find(j.TemplateLiteral).paths();
+          _iterator = _createForOfIteratorHelper(templateLiteralPaths);
+          _context2.prev = 11;
+          _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
+            var path, text, quasiPaths, _iterator2, _step2, quasiPath, _text, newCSS;
+            return _regeneratorRuntime.wrap(function _loop$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  path = _step.value;
+                  // Background: a 'type: TemplateLiteral' Node has quasis and expressions
+                  // (see ast-types/src/gen/namedTypes.ts), and invariant holds that
+                  // quasis.length === expression.length + 1.
+                  //
+                  // eg `${foo}bar` has quasis [Node(''), Node('bar')] and expressions
+                  // [Node('foo')]. Each quasi has type: 'TemplateElement'; expressions are
+                  // probably safe to treat as subtypes of Expression, though ast-types
+                  // codebase has a more involved definition.
+                  if (path.value.expressions.length === 0) {
+                    // A single-quasi (equivalently, no-expression) template literal is
+                    // basically just a string literal, possibly multi-line. We handle the
+                    // simple `#ababab` case here, and the multi-line case after.
+                    text = path.value.quasis[0].value.raw;
+                    if (replaceStringLiteralIfItConsistsOnlyOfColor(j, path, text)) {
+                      transformed = true;
+                    }
+                  } else {
+                    j(path).find(j.Expression).filter(function (expressionPath) {
+                      // jscodeshift walks over the whole tree; we are interested only in
+                      // the direct children: i.e. top-level expressions appearing in ${}.
+                      return expressionPath.parent === path;
+                    }).forEach(function (expressionPath, expressionIndex) {
+                      if (replaceTemplateLiteralExpression(j, path, expressionPath, expressionIndex)) {
+                        transformed = true;
+                      }
+                    });
+                  }
 
-  // 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') {
-      return;
-    }
-    if (isParentOfToken(j, path)) {
-      return;
-    }
-    var expression = path.value.value.expression;
-    var value = getColorFromIdentifier(expression);
-    if (!value || !includesHardCodedColor(value) && !isHardCodedColor(value) && !isLegacyColor(value) && !isLegacyNamedColor(value)) {
-      return;
-    }
-    var tokenId = getTokenFromNode(j, path, value, path.value.name.name);
-    insertTokenImport(j, source);
-    j(path).find(j.JSXExpressionContainer).forEach(function (path) {
-      var tokenNode = buildToken(j, tokenId, path.value.expression);
-      j(path).replaceWith(j.jsxExpressionContainer(tokenNode));
-    });
-    transformed = true;
-  });
-  return transformed ? source.toSource() : file.source;
+                  // No matter if we have one big quasi or many small chunks between
+                  // expressions (which potentially have been transformed), try to pass them
+                  // through the CSS transformer; it's robust enough to understand malformed
+                  // CSS that would result if we split e.g. this template:
+                  //
+                  // `${gridSize}px; color: red;`, giving `px; color: red;` as input; or
+                  // `@media ${mobile} { color: red }`, giving `{ color: red }`.
+                  quasiPaths = j(path).find(j.TemplateElement).filter(function (quasiPath) {
+                    return quasiPath.parent === path;
+                  }).paths();
+                  _iterator2 = _createForOfIteratorHelper(quasiPaths);
+                  _context.prev = 4;
+                  _iterator2.s();
+                case 6:
+                  if ((_step2 = _iterator2.n()).done) {
+                    _context.next = 17;
+                    break;
+                  }
+                  quasiPath = _step2.value;
+                  _text = quasiPath.value.value.raw;
+                  if (!(includesHardCodedColor(_text) && containsReplaceableCSSDeclarations(_text))) {
+                    _context.next = 15;
+                    break;
+                  }
+                  _context.next = 12;
+                  return CSSTransformer(_text);
+                case 12:
+                  newCSS = _context.sent;
+                  j(quasiPath).replaceWith(buildTemplateElement(j, newCSS));
+                  transformed = true;
+                case 15:
+                  _context.next = 6;
+                  break;
+                case 17:
+                  _context.next = 22;
+                  break;
+                case 19:
+                  _context.prev = 19;
+                  _context.t0 = _context["catch"](4);
+                  _iterator2.e(_context.t0);
+                case 22:
+                  _context.prev = 22;
+                  _iterator2.f();
+                  return _context.finish(22);
+                case 25:
+                case "end":
+                  return _context.stop();
+              }
+            }, _loop, null, [[4, 19, 22, 25]]);
+          });
+          _iterator.s();
+        case 14:
+          if ((_step = _iterator.n()).done) {
+            _context2.next = 18;
+            break;
+          }
+          return _context2.delegateYield(_loop(), "t0", 16);
+        case 16:
+          _context2.next = 14;
+          break;
+        case 18:
+          _context2.next = 23;
+          break;
+        case 20:
+          _context2.prev = 20;
+          _context2.t1 = _context2["catch"](11);
+          _iterator.e(_context2.t1);
+        case 23:
+          _context2.prev = 23;
+          _iterator.f();
+          return _context2.finish(23);
+        case 26:
+          return _context2.abrupt("return", transformed ? source.toSource() : file.source);
+        case 27:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee, null, [[11, 20, 23, 26]]);
+  }));
+  return _transformer.apply(this, arguments);
 }

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

@@ -1,6 +1,6 @@
 import { isDecendantOfType } from '@codeshift/utils';
 export function isDecendantOfToken(j, path) {
-  if (path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
+  if ('type' in path && path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
     return true;
   }
   return j(path).closest(j.CallExpression, {

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

@@ -6,9 +6,10 @@ export var isLegacyColor = function isLegacyColor(value) {
 export var isLegacyNamedColor = function isLegacyNamedColor(value) {
   return legacyColorMixins.includes(value);
 };
+var colorRegexp = /#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})\b|(?:rgb|rgba|hsl|hsla|lch|lab|color)\([^\)]*\)/;
 export 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())) {
+  if (colorRegexp.exec(value)) {
     return true;
   }
   for (var i = 0; i < namedColors.length; i++) {
@@ -18,17 +19,18 @@ export var includesHardCodedColor = function includesHardCodedColor(raw) {
   }
   return false;
 };
-export var isHardCodedColor = function isHardCodedColor(value) {
-  if (namedColors.includes(value.toLowerCase())) {
-    return true;
-  }
-  if (value.startsWith('rgb(') || value.startsWith('rgba(') || value.startsWith('hsl(') || value.startsWith('hsla(') || value.startsWith('lch(') || value.startsWith('lab(') || value.startsWith('color(')) {
+export var isHardCodedColor = function isHardCodedColor(raw) {
+  var value = raw.toLowerCase();
+  if (namedColors.includes(value)) {
     return true;
   }
-  if (value.startsWith('#') && (
-  // short hex, hex, or hex with alpha
-  value.length === 4 || value.length === 7 || value.length === 9)) {
+  var match = value.toLowerCase().match(colorRegexp);
+  if (match && match[0] === value) {
     return true;
   }
   return false;
-};
+};
+export function isBoldColor(color) {
+  var number = parseInt(color.replace(/^./, ''), 10);
+  return number > 300;
+}

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

@@ -0,0 +1,31 @@
+import { isColorRelatedProperty } from '../../css-to-design-tokens/lib/declaration';
+export function containsReplaceableCSSDeclarations(input) {
+  var cssPattern = /(\S+)\s*:/g;
+  var match;
+  while ((match = cssPattern.exec(input)) !== null) {
+    if (isColorRelatedProperty(match[1])) {
+      return true;
+    }
+  }
+  return false;
+}
+export function findEndIndexOfCSSExpression(text, isAtEndOfInput) {
+  // CSS expression can end *on* a semicolon or *before* a brace. In either
+  // case we treat the remaining part of the value to cover one character
+  // before that symbol.
+  var semicolonIndex = text.indexOf(';');
+  var braceIndex = text.indexOf('}');
+  if (semicolonIndex === -1 && braceIndex === -1) {
+    if (isAtEndOfInput) {
+      return text.length;
+    } else {
+      return null;
+    }
+  } else if (semicolonIndex === -1) {
+    return braceIndex - 1;
+  } else if (braceIndex === -1) {
+    return semicolonIndex - 1;
+  } else {
+    return Math.min(semicolonIndex, braceIndex) - 1;
+  }
+}

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

@@ -0,0 +1,17 @@
+export var kebabize = function kebabize(str) {
+  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, function ($, ofs) {
+    return (ofs ? '-' : '') + $.toLowerCase();
+  });
+};
+export function findFirstNonspaceIndexAfter(text, index) {
+  var rest = text.slice(index + 1);
+  var indexInRest = rest.search(/\S/);
+  if (indexInRest === -1) {
+    return text.length;
+  } else {
+    return index + 1 + indexInRest;
+  }
+}
+export function splitAtIndex(text, index) {
+  return [text.slice(0, index), text.slice(index)];
+}

package/dist/types/main.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Flags, Default } from './types';
 declare const defaultFlags: {
     parser: "babel";

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

@@ -1,2 +1,2 @@
 import { FileInfo } from 'jscodeshift';
-export default function transformer(file: FileInfo): Promise<string>;
+export default function transformer(file: FileInfo | string): Promise<string>;

package/dist/types/presets/css-to-design-tokens/lib/colors.d.ts

@@ -0,0 +1,6 @@
+export declare function isKnownCssVariable(value: string): boolean;
+export declare function isRawColor(value: string): boolean;
+export declare function isNamedColor(value: string): boolean;
+export declare function isGradient(value: string): boolean;
+export declare function extractBetweenParentheses(value: string): string;
+export declare function isLessFunction(value: string): boolean;

package/dist/types/presets/css-to-design-tokens/lib/declaration.d.ts

@@ -0,0 +1,5 @@
+export declare function isColorRelatedProperty(prop: string): boolean;
+export declare function isCssDeclaration(prop: string): boolean;
+export declare function extractCssVarName(prop: string): string;
+export declare function extractLessVarName(prop: string): string;
+export declare function splitCssValue(value: string): RegExpMatchArray | null;

package/dist/types/presets/css-to-design-tokens/{utils → lib}/legacy-colors.d.ts

@@ -1,3 +1,3 @@
 export declare const knownVariables: Record<string, string[]>;
-export declare const knownColors: Record<string, string[]>;
+export declare const knownNamedColors: Record<string, string[]>;
 export declare const knownRawColors: Record<string, string[]>;

package/dist/types/presets/css-to-design-tokens/lib/logger.d.ts

@@ -0,0 +1,4 @@
+export declare const logger: {
+    warn(message: string): void;
+    error(message: string): void;
+};

package/dist/types/presets/css-to-design-tokens/lib/meta.d.ts

@@ -0,0 +1,6 @@
+import { Declaration } from 'postcss';
+export declare function cleanMeta(meta: string[]): string[];
+export declare function getBaseDeclarationMeta(decl: Declaration): string[];
+export declare function getCssVarMeta(cssVariable: string): string[];
+export declare function getRawColorMeta(rawColor: string): string[];
+export declare function getNamedColorMeta(namedColor: string): string[];

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

@@ -0,0 +1,7 @@
+import designTokens from '@atlaskit/tokens/token-names';
+type DesignTokensMap = typeof designTokens;
+type DesignTokenJs = keyof DesignTokensMap;
+type DesignTokenCss = DesignTokensMap[DesignTokenJs];
+declare const MISSING_TOKEN_NAME = "MISSING_TOKEN";
+export default function findToken(meta: string[]): DesignTokenCss | typeof MISSING_TOKEN_NAME;
+export {};

package/dist/types/presets/css-to-design-tokens/lib/value.d.ts

@@ -0,0 +1,6 @@
+interface Value {
+    getReplacement: (additionalMeta?: string[]) => string;
+    getMeta: () => string[];
+}
+export default function parseValue(value: string): Value | null;
+export {};

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

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