@atlaskit/codemod-cli 0.17.10 → 0.19.0

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

@@ -1,484 +0,0 @@
-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, isBoldColor } from './utils/color';
-import Search from './utils/fuzzy-search';
-import { legacyColorMetaMap } from './utils/legacy-colors';
-import { tokens } from './utils/tokens';
-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;
-  }
-  var newImport = j.importDeclaration([j.importSpecifier(j.identifier('token'))], j.stringLiteral('@atlaskit/tokens'));
-  source.get().node.program.body.unshift(newImport);
-}
-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') {
-    value = expression.name;
-  }
-  if (expression.type === 'StringLiteral') {
-    value = expression.value;
-  }
-  if (expression.type === 'MemberExpression' && expression.object.name === 'colors' && isLegacyColor(expression.property.name)) {
-    value = expression.property.name;
-  }
-  return value;
-}
-function getTokenFromNode(j, path, value, propertyName) {
-  var valueMeta = cleanMeta(legacyColorMetaMap[value] || []);
-  var ancestorMeta = cleanMeta([].concat(_toConsumableArray(getMetaFromAncestors(j, path)), _toConsumableArray(kebabize(propertyName).split('-'))) || []);
-  var property = cleanMeta([kebabize(propertyName)])[0];
-
-  // Attempt to find a property from ancestors if one is not found
-  if (!property || !['border', 'icon', 'background', 'text'].includes(property)) {
-    if (ancestorMeta.includes('border')) {
-      property = 'border';
-    }
-    if (ancestorMeta.includes('icon')) {
-      property = 'icon';
-    }
-    if (ancestorMeta.includes('background')) {
-      property = 'background';
-    }
-    if (ancestorMeta.includes('color')) {
-      property = 'text';
-    }
-  }
-  var meta = [];
-  var possibleTokens = tokens;
-  if (property === 'text') {
-    possibleTokens = tokens.filter(function (token) {
-      return token.includes('.text');
-    });
-    if (valueMeta.includes('neutral')) {
-      meta.push('color', 'text');
-    }
-    if (valueMeta.includes('neutral') && (value === 'N400' || value === 'N500')) {
-      meta.push('color', 'text', 'subtle');
-    }
-    if (valueMeta.includes('neutral') && (value === 'N80' || value === 'N100' || value === 'N200' || value === 'N300' || value === 'N400')) {
-      meta.push('color', 'text', 'subtlest');
-    }
-
-    // handle non-neutrals
-    if (!valueMeta.includes('neutral')) {
-      meta.push.apply(meta, ['color'].concat(_toConsumableArray(ancestorMeta), _toConsumableArray(valueMeta)));
-    }
-  }
-  if (property === 'background' || property === 'background-color') {
-    if (ancestorMeta.includes('disabled')) {
-      // disabled backgrounds
-      meta.push.apply(meta, [property].concat(_toConsumableArray(ancestorMeta)));
-    } else if (
-    // Surfaces
-    valueMeta.includes('neutral') && value !== 'N100' && value !== 'N200' && value !== 'N300' && value !== 'N400' && value !== 'N500' && value !== 'N600' && value !== 'N700' && value !== 'N800') {
-      meta.push.apply(meta, ['surface'].concat(_toConsumableArray(ancestorMeta)));
-    } else if (value.includes('N0')) {
-      // default surface
-      meta.push('elevation', 'surface');
-    } else if (valueMeta.includes('neutral') && isBoldColor(value)) {
-      // bold netural backgrounds
-      meta.push('background', 'neutral', 'bold');
-    } else if (valueMeta.includes('neutral')) {
-      // netural backgrounds
-      meta.push('background', 'neutral');
-    }
-  }
-  if (property === 'border' || property === 'border-color' || property === 'border-left' || property === 'border-right' || property === 'border-top' || property === 'border-bottom' || property === 'outline' || property === 'outline-color') {
-    possibleTokens = tokens.filter(function (token) {
-      return token.includes('.border') || token.includes('.focus');
-    });
-    if (valueMeta.includes('neutral')) {
-      // standard netural boarder
-      meta.push.apply(meta, ['color', 'border'].concat(_toConsumableArray(ancestorMeta)));
-    } else {
-      meta.push.apply(meta, ['border'].concat(_toConsumableArray(valueMeta), _toConsumableArray(ancestorMeta)));
-    }
-  }
-  if (ancestorMeta.includes('icon')) {
-    possibleTokens = tokens.filter(function (token) {
-      return token.includes('.icon');
-    });
-    if (ancestorMeta.includes('disabled')) {
-      // disabled backgrounds
-      meta.push('disabled');
-    }
-    meta.push.apply(meta, ['color', 'icon'].concat(_toConsumableArray(valueMeta)));
-  }
-
-  // Fallback if guided behavior yields nothing
-  if (meta.length === 0) {
-    meta.push.apply(meta, [property].concat(_toConsumableArray(valueMeta), _toConsumableArray(ancestorMeta)));
-  }
-  var search = Search(possibleTokens, false);
-  var results = search.get(meta.join(' '));
-  var tokenId = ['MISSING_TOKEN'];
-  if (results) {
-    tokenId = results.map(function (result) {
-      return result[1];
-    });
-  }
-  return tokenId[0];
-}
-function parseCSSPropertyName(cssString) {
-  var lastColonIndex = cssString.lastIndexOf(':');
-  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);
-}
-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;
-            }
-
-            // 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;
-          });
-
-          // 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;
-          });
-
-          // 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;
-                      }
-                    });
-                  }
-
-                  // 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/types.js

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

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

@@ -1,74 +0,0 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
-import { getClosestDecendantOfType } from './ast';
-import { getUniqueWordsFromTokens } from './tokens';
-export function getMetaFromAncestors(j, path) {
-  var meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
-  var parent = path.parentPath;
-  var grandParent = parent && parent.parentPath;
-  if (parent && parent.value.type === 'ObjectProperty') {
-    var value = '';
-    if (parent.value.key.type === 'Literal' || parent.value.key.type === 'StringLiteral' || parent.value.key.type === 'NumericLiteral') {
-      value = parent.value.key.value.toString();
-    } else {
-      value = parent.value.key.name;
-    }
-    meta.push(value);
-  }
-  if (parent && grandParent && grandParent.value.type === 'TemplateLiteral') {
-    var expressionIndex = grandParent.value.expressions.findIndex(function (exp) {
-      return exp.name === path.value.name;
-    });
-    var quasi = grandParent.value.quasis[expressionIndex];
-    var propertyName = (quasi.value.cooked || quasi.value.raw || '').replace(/\n/g, '').split(/;|{|}/).filter(function (el) {
-      return !el.match(/\.|\@|\(|\)/);
-    }).pop().split(/:/g)[0].trim();
-    grandParent.value.quasis.slice(0, expressionIndex + 1).map(function (q) {
-      return q.value.cooked;
-    })
-    // We reverse so the most nested one is first which we're more likely than not interested in
-    .reverse().some(function (str) {
-      var result = /(hover|active|disabled|focus)/.exec(str.toLowerCase());
-      if (result) {
-        meta.push(result[0]);
-        return true;
-      }
-    });
-    meta.push(propertyName);
-  }
-  if (parent && parent.value.type === 'JSXAttribute') {
-    if (!['css', 'styles', 'style', 'fill', 'stopColor', 'startColor'].includes(parent.value.name.name)) {
-      meta.push(parent.value.name.name);
-    }
-  }
-  var closestJSXElement = getClosestDecendantOfType(j, path, j.JSXOpeningElement);
-  if (closestJSXElement) {
-    var jsxElementName = closestJSXElement.value.name.name;
-    var nameComponents = jsxElementName.replace(/([a-z])([A-Z])/g, '$1 $2').split(' ');
-    meta.push.apply(meta, _toConsumableArray(nameComponents));
-  }
-  if (parent && parent.value.type === 'VariableDeclarator') {
-    meta.push(parent.value.id.name);
-  }
-  if (parent) {
-    return getMetaFromAncestors(j, parent, meta);
-  }
-  return meta;
-}
-export function cleanMeta(meta) {
-  return meta.reduce(function (accum, val) {
-    return [].concat(_toConsumableArray(accum), _toConsumableArray(typeof val === 'string' ? val.split(/(?=[A-Z])/g).map(function (e) {
-      return e.toLowerCase();
-    }) : []));
-  }, []).reduce(function (accum, val) {
-    var cleanVal = val.replace(/:/g, '').replace(/,/g, '').replace('grey', 'neutral').replace('skeleton', 'neutral').replace('texts', 'text').replace('red', 'danger').replace('error', 'danger').replace('invalid', 'danger').replace('removed', 'danger').replace('removal', 'danger').replace('remove', 'danger').replace('focus', 'focused').replace('valid', 'success').replace('successful', 'success').replace('risk', 'warning').replace('caution', 'warning').replace('primary', 'bold').replace('secondary', 'subtle').replace('hyperlink', 'link').replace('anchor', 'link').replace('active', 'pressed').replace('hover', 'hovered').replace('card', 'raised').replace('dragged', 'surface overlay').replace('dragging', 'surface overlay').replace('drag', 'surface overlay').replace('background-color', 'background').replace('color', 'text').replace('icons', 'icon').replace('glyph', 'icon').replace('stroke', 'border').replace('border-left', 'border').replace('border-right', 'border').replace('border-top', 'border').replace('border-bottom', 'border').replace('box-shadow', 'shadow');
-    accum.push.apply(accum, _toConsumableArray(cleanVal.split(' ')));
-    return accum;
-  }, []).filter(function (val) {
-    return getUniqueWordsFromTokens.includes(val);
-  }).reduce(function (accum, val) {
-    if (!accum.includes(val)) {
-      accum.push(val);
-    }
-    return accum;
-  }, []);
-}

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

@@ -1,27 +0,0 @@
-import { isDecendantOfType } from '@codeshift/utils';
-export function isDecendantOfToken(j, path) {
-  if ('type' in path && path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
-    return true;
-  }
-  return j(path).closest(j.CallExpression, {
-    callee: {
-      name: 'token'
-    }
-  }).length > 0;
-}
-export function isParentOfToken(j, path) {
-  if (path.type === 'CallExpression' && path.callee.type === 'Identifier' && path.callee.name === 'token') {
-    return true;
-  }
-  return j(path).find(j.CallExpression, {
-    callee: {
-      name: 'token'
-    }
-  }).length > 0;
-}
-export function getClosestDecendantOfType(j, path, type) {
-  if (!isDecendantOfType(j, path, type)) {
-    return;
-  }
-  return j(path).closest(type).get();
-}

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

@@ -1,36 +0,0 @@
-import { legacyColorMixins, legacyColors } from './legacy-colors';
-import { namedColors } from './named-colors';
-export var isLegacyColor = function isLegacyColor(value) {
-  return legacyColors.includes(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 (colorRegexp.exec(value)) {
-    return true;
-  }
-  for (var i = 0; i < namedColors.length; i++) {
-    if (value.includes("".concat(namedColors[i], ";"))) {
-      return true;
-    }
-  }
-  return false;
-};
-export var isHardCodedColor = function isHardCodedColor(raw) {
-  var value = raw.toLowerCase();
-  if (namedColors.includes(value)) {
-    return true;
-  }
-  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

@@ -1,31 +0,0 @@
-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;
-  }
-}