@atlaskit/codemod-cli 0.14.0 → 0.16.0

package/dist/esm/presets/css-to-design-tokens/lib/meta.js

@@ -0,0 +1,146 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import designTokens from '@atlaskit/tokens/token-names';
+import { extractCssVarName } from './declaration';
+import { knownVariables, knownRawColors, knownNamedColors } from './legacy-colors';
+var getUniqueWordsFromTokens = Object.keys(designTokens).reduce(function (accum, val) {
+  return [].concat(_toConsumableArray(accum), _toConsumableArray(val.split('.')));
+}, []).reduce(function (accum, val) {
+  return [].concat(_toConsumableArray(accum), _toConsumableArray(val.split(/(?=[A-Z])/g).map(function (e) {
+    return e.toLowerCase();
+  })));
+}, []).reduce(function (accum, val) {
+  if (!accum.includes(val)) {
+    accum.push(val);
+  }
+  return accum;
+}, []);
+function filterDuplciateFoundations(meta) {
+  var foundations = ['text', 'background', 'shadow', 'border'];
+  var hasFoundation = false;
+  return meta.filter(function (val) {
+    if (!hasFoundation && foundations.includes(val)) {
+      hasFoundation = true;
+      return true;
+    }
+    if (hasFoundation && foundations.includes(val)) {
+      return false;
+    }
+    return true;
+  });
+}
+var REPLACEMENTS = {
+  ':': '',
+  ',': '',
+  texts: 'text',
+  error: 'danger',
+  invalid: 'danger',
+  removed: 'danger',
+  removal: 'danger',
+  remove: 'danger',
+  focus: 'focused',
+  valid: 'success',
+  successful: 'success',
+  risk: 'warning',
+  caution: 'warning',
+  warn: 'warning',
+  primary: 'bold',
+  info: 'bold',
+  secondary: 'subtle',
+  hyperlink: 'link',
+  anchor: 'link',
+  active: 'pressed',
+  hover: 'hovered',
+  dragged: 'overlay',
+  dragging: 'overlay',
+  drag: 'overlay',
+  'background-color': 'background',
+  color: 'text',
+  icons: 'icon',
+  arrow: 'icon',
+  glyph: 'icon',
+  stroke: 'border',
+  'border-left': 'border',
+  'border-right': 'border',
+  'border-top': 'border',
+  'border-bottom': 'border',
+  'box-shadow': 'shadow'
+};
+var ADDITIONAL_META = {
+  grey: 'neutral',
+  red: 'danger'
+};
+export function cleanMeta(meta) {
+  var cleanMeta = 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) {
+    if (val in ADDITIONAL_META) {
+      accum.push(val, ADDITIONAL_META[val]);
+    } else {
+      accum.push(val);
+    }
+    accum.push(val in REPLACEMENTS ? REPLACEMENTS[val] : val);
+    return accum;
+  }, []).filter(function (val) {
+    return getUniqueWordsFromTokens.includes(val);
+  }).reduce(function (accum, val) {
+    if (!accum.includes(val)) {
+      accum.push(val);
+    }
+    return accum;
+  }, []);
+  return filterDuplciateFoundations(cleanMeta);
+}
+export function getBaseDeclarationMeta(decl) {
+  var parentSelectors = getParentSelectors(decl).split(/\-|\.|\,|\ |\:|\&/).filter(Boolean);
+  return [getPropertyMeta(decl.prop)].concat(_toConsumableArray(parentSelectors));
+}
+function getPropertyMeta(prop) {
+  if (prop === 'color') {
+    return 'text';
+  }
+  if (prop.startsWith('background')) {
+    return 'background';
+  }
+  if (prop.includes('shadow')) {
+    return 'shadow';
+  }
+  if (prop.includes('border')) {
+    return 'border';
+  }
+  return '';
+}
+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 '';
+}
+export function getCssVarMeta(cssVariable) {
+  var tokenName = extractCssVarName(cssVariable);
+  var meta = knownVariables[tokenName];
+  if (!meta || meta.length === 0) {
+    return tokenName.split('-');
+  }
+  return meta;
+}
+export function getRawColorMeta(rawColor) {
+  var _knownRawColors$clean;
+  var cleanColor = rawColor.toLowerCase();
+  if (cleanColor.length === 4) {
+    cleanColor = cleanColor + cleanColor.substring(cleanColor.indexOf('#') + 1);
+  }
+  return (_knownRawColors$clean = knownRawColors[cleanColor]) !== null && _knownRawColors$clean !== void 0 ? _knownRawColors$clean : [];
+}
+export function getNamedColorMeta(namedColor) {
+  var _knownNamedColors$nam;
+  return (_knownNamedColors$nam = knownNamedColors[namedColor]) !== null && _knownNamedColors$nam !== void 0 ? _knownNamedColors$nam : [];
+}

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

@@ -0,0 +1,40 @@
+import designTokens from '@atlaskit/tokens/token-names';
+import { light as rawTokens } from '@atlaskit/tokens/tokens-raw';
+import Search from '../../theme-to-design-tokens/utils/fuzzy-search';
+import { cleanMeta } from './meta';
+var MISSING_TOKEN_NAME = 'MISSING_TOKEN';
+var ACTIVE_TOKENS = rawTokens.filter(function (token) {
+  return token.attributes.state === 'active';
+}).map(function (token) {
+  return token.name.replace(/\.\[default\]/g, '');
+}).filter(function (token) {
+  return !token.includes('UNSAFE') && !token.includes('interaction');
+});
+var COLOR_TOKEN_SEARCH_TYPES = ['text', 'link', 'icon', 'border', 'background', 'blanket', 'skeleton', 'chart', 'surface', 'shadow'];
+var createFuzzySearch = function createFuzzySearch(tokens) {
+  return Search(tokens, false);
+};
+function filterTokens(meta) {
+  var commonSearchTypes = COLOR_TOKEN_SEARCH_TYPES.filter(function (type) {
+    return meta.includes(type);
+  });
+  return commonSearchTypes.length !== 0 ? ACTIVE_TOKENS.filter(function (token) {
+    return commonSearchTypes.some(function (type) {
+      return token.startsWith("color.".concat(type)) || token.startsWith("elevation.".concat(type));
+    });
+  }) : ACTIVE_TOKENS;
+}
+export default function findToken(meta) {
+  var filteredTokens = filterTokens(meta);
+  var tokenFuzzySearch = createFuzzySearch(filteredTokens);
+  var cleanSearchTerms = cleanMeta(meta).join(' ');
+  var results = tokenFuzzySearch.get(cleanSearchTerms);
+  if (!results) {
+    return MISSING_TOKEN_NAME;
+  }
+  var candidates = results.map(function (result) {
+    return result[1];
+  });
+  var bestCandidate = designTokens[candidates[0]];
+  return bestCandidate;
+}

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

@@ -0,0 +1,73 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { extractBetweenParentheses, isGradient, isKnownCssVariable, isLessFunction, isNamedColor, isRawColor } from './colors';
+import { extractCssVarName } from './declaration';
+import { getCssVarMeta, getNamedColorMeta, getRawColorMeta } from './meta';
+import findToken from './tokens';
+import { logger } from './logger';
+export default function parseValue(value) {
+  if (isLessFunction(value)) {
+    logger.warn('Cannot parse - less function detected, would cause compilation error');
+    return null;
+  }
+  if (isGradient(value)) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var gradientContent = 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 = extractBetweenParentheses(value);
+        var values = gradientContent.split(',');
+        var metas = values.reduce(function (acc, val) {
+          var parsedValue = parseValue(val.trim());
+          return parsedValue ? [].concat(_toConsumableArray(acc), _toConsumableArray(parsedValue.getMeta())) : acc;
+        }, BASE_META);
+        return metas;
+      }
+    };
+  }
+  if (isKnownCssVariable(extractCssVarName(value))) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var token = findToken([].concat(_toConsumableArray(additionalMeta), _toConsumableArray(this.getMeta())));
+        return "var(".concat(token, ", ").concat(value, ")");
+      },
+      getMeta: function getMeta() {
+        return getCssVarMeta(value);
+      }
+    };
+  }
+  if (isRawColor(value)) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var token = findToken([].concat(_toConsumableArray(additionalMeta), _toConsumableArray(this.getMeta())));
+        return "var(".concat(token, ", ").concat(value, ")");
+      },
+      getMeta: function getMeta() {
+        return getRawColorMeta(value);
+      }
+    };
+  }
+  if (isNamedColor(value)) {
+    return {
+      getReplacement: function getReplacement() {
+        var additionalMeta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        var token = findToken([].concat(_toConsumableArray(additionalMeta), _toConsumableArray(this.getMeta())));
+        return "var(".concat(token, ", ").concat(value, ")");
+      },
+      getMeta: function getMeta() {
+        return getNamedColorMeta(value);
+      }
+    };
+  }
+  return null;
+}

package/dist/esm/presets/index.js

@@ -8,7 +8,8 @@ import './styled-to-emotion/styled-to-emotion';
 import './theme-to-design-tokens/theme-to-design-tokens';
 import './theme-remove-deprecated-mixins/theme-remove-deprecated-mixins';
 import './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) {
+import './migrate-to-new-buttons/migrate-to-new-buttons';
+var presets = ['styled-to-emotion', 'theme-to-design-tokens', 'theme-remove-deprecated-mixins', 'css-to-design-tokens', 'migrate-to-new-buttons'].map(function (preset) {
   return path.join(__dirname, preset, "".concat(preset, ".@(ts|js|tsx)"));
 });
 export default presets;

package/dist/esm/presets/migrate-to-new-buttons/codemods/next-migrate-to-new-button-variants.js

@@ -0,0 +1,112 @@
+import { PRINT_SETTINGS, NEW_BUTTON_VARIANTS, entryPointsMapping, NEW_BUTTON_ENTRY_POINT } from '../utils/constants';
+var transformer = function transformer(file, api) {
+  var j = api.jscodeshift;
+  var fileSource = j(file.source);
+  var buttonImports = fileSource.find(j.ImportDeclaration).filter(function (path) {
+    return path.node.source.value === entryPointsMapping.Button || path.node.source.value === NEW_BUTTON_ENTRY_POINT;
+  });
+  if (!buttonImports.length) {
+    return fileSource.toSource();
+  }
+  var defaultButtonImport = buttonImports.find(j.Specifier).filter(function (path) {
+    return path.node.type === 'ImportDefaultSpecifier';
+  });
+  if (defaultButtonImport.length === 0) {
+    return fileSource.toSource();
+  }
+  var specifierIdentifier = defaultButtonImport.get(0).node.local.name;
+  var attributes = fileSource.find(j.JSXElement).filter(function (path) {
+    return path.value.openingElement.name.type === 'JSXIdentifier' && path.value.openingElement.name.name === specifierIdentifier;
+  }).find(j.JSXAttribute);
+  var hasCustomComponent = attributes.filter(function (attribute) {
+    return attribute.node.name.name === 'component';
+  }).length > 0;
+  var hasCssProp = attributes.filter(function (attribute) {
+    return attribute.node.name.name === 'css';
+  }).length > 0;
+  if (hasCustomComponent || hasCssProp) {
+    return fileSource.toSource(PRINT_SETTINGS);
+  }
+  var checkIfVariantAlreadyImported = function checkIfVariantAlreadyImported(variant) {
+    return fileSource.find(j.ImportDeclaration).filter(function (path) {
+      return path.node.source.value === NEW_BUTTON_ENTRY_POINT;
+    }).find(j.ImportSpecifier).filter(function (path) {
+      return path.node.imported.name === variant;
+    }).length > 0;
+  };
+  var generateNewElement = function generateNewElement(variant, element) {
+    var attributes = element.openingElement.attributes;
+    if (variant === NEW_BUTTON_VARIANTS.icon.as) {
+      var attr = attributes === null || attributes === void 0 ? void 0 : attributes.filter(function (attribute) {
+        return attribute.type === 'JSXAttribute' && (attribute.name.name === 'iconBefore' || attribute.name.name === 'iconAfter');
+      });
+      if (attr !== null && attr !== void 0 && attr.length && attr[0].type === 'JSXAttribute') {
+        attr[0].name.name = 'icon';
+      }
+    }
+    // self closing if it's an icon button or icon link button
+    var isSelfClosing = variant === NEW_BUTTON_VARIANTS.icon.as || variant === NEW_BUTTON_VARIANTS.linkIcon.as;
+    return j.jsxElement(j.jsxOpeningElement(j.jsxIdentifier(variant), attributes, isSelfClosing), isSelfClosing ? null : j.jsxClosingElement(j.jsxIdentifier(variant)), element.children);
+  };
+  var hasLinkIconButton = checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.linkIcon.import);
+  var hasLinkButton = checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.link.import);
+  var hasIconButton = checkIfVariantAlreadyImported(NEW_BUTTON_VARIANTS.icon.import);
+  var allButtons = fileSource.find(j.JSXElement).filter(function (path) {
+    return path.value.openingElement.name.type === 'JSXIdentifier' && path.value.openingElement.name.name === specifierIdentifier;
+  });
+  allButtons.forEach(function (element) {
+    var _element$value$childr, _element$value$childr2;
+    var attributes = element.value.openingElement.attributes;
+    if (!attributes) {
+      return;
+    }
+    var buttonAttributes = attributes.map(function (node) {
+      return node.type === 'JSXAttribute' && node.name.name;
+    });
+    var hasHref = buttonAttributes.includes('href');
+    var hasIcon = buttonAttributes.includes('iconBefore') || buttonAttributes.includes('iconAfter');
+    var isLinkIconButton = hasHref && hasIcon && ((_element$value$childr = element.value.children) === null || _element$value$childr === void 0 ? void 0 : _element$value$childr.length) === 0;
+    var isLinkButton = hasHref && !isLinkIconButton;
+    var isIconButton = !hasHref && hasIcon && ((_element$value$childr2 = element.value.children) === null || _element$value$childr2 === void 0 ? void 0 : _element$value$childr2.length) === 0;
+    if (isLinkIconButton) {
+      hasLinkIconButton = true;
+      j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.linkIcon.as, element.value));
+    }
+    if (isIconButton) {
+      hasIconButton = true;
+      j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.icon.as, element.value));
+    }
+    if (isLinkButton) {
+      hasLinkButton = true;
+      j(element).replaceWith(generateNewElement(NEW_BUTTON_VARIANTS.link.as, element.value));
+    }
+  });
+  var specifiers = [];
+  if (hasLinkButton) {
+    specifiers.push(j.importSpecifier(j.identifier(NEW_BUTTON_VARIANTS.link.import), j.identifier(NEW_BUTTON_VARIANTS.link.as)));
+  }
+  if (hasIconButton) {
+    specifiers.push(j.importSpecifier(j.identifier(NEW_BUTTON_VARIANTS.icon.import), j.identifier(NEW_BUTTON_VARIANTS.icon.as)));
+  }
+  if (hasLinkIconButton) {
+    specifiers.push(j.importSpecifier(j.identifier(NEW_BUTTON_VARIANTS.linkIcon.import), j.identifier(NEW_BUTTON_VARIANTS.linkIcon.as)));
+  }
+  var oldButtonImport = fileSource.find(j.ImportDeclaration).filter(function (path) {
+    return path.node.source.value === NEW_BUTTON_ENTRY_POINT || path.node.source.value === entryPointsMapping.Button;
+  });
+  var leftButtons = fileSource.find(j.JSXElement).filter(function (path) {
+    return path.value.openingElement.name.type === 'JSXIdentifier' && path.value.openingElement.name.name === specifierIdentifier;
+  }).length > 0 || fileSource.find(j.CallExpression).filter(function (path) {
+    return path.node.arguments.map(function (argument) {
+      return argument.type === 'Identifier' && (argument === null || argument === void 0 ? void 0 : argument.name);
+    }).includes(specifierIdentifier);
+  }).length > 0;
+  if (specifiers.length || leftButtons) {
+    if (leftButtons) {
+      specifiers.push(j.importSpecifier(j.identifier(NEW_BUTTON_VARIANTS.default.import), j.identifier(specifierIdentifier)));
+    }
+    oldButtonImport.replaceWith(j.importDeclaration(specifiers, j.stringLiteral(NEW_BUTTON_ENTRY_POINT)));
+  }
+  return fileSource.toSource(PRINT_SETTINGS);
+};
+export default transformer;

package/dist/esm/presets/migrate-to-new-buttons/codemods/next-split-imports.js

@@ -0,0 +1,52 @@
+import { PRINT_SETTINGS, entryPointsMapping, BUTTON_TYPES } from '../utils/constants';
+var transformer = function transformer(file, api) {
+  var j = api.jscodeshift;
+  var fileSource = j(file.source);
+  var buttonImports = fileSource.find(j.ImportDeclaration).filter(function (path) {
+    var _path$node$source$val;
+    return (_path$node$source$val = path.node.source.value) === null || _path$node$source$val === void 0 ? void 0 : _path$node$source$val.includes('@atlaskit/button');
+  });
+  if (!buttonImports.length || buttonImports.every(function (node) {
+    return node.node.source.value !== '@atlaskit/button';
+  })) {
+    return fileSource.toSource(PRINT_SETTINGS);
+  }
+  buttonImports.forEach(function (node) {
+    var specifiers = node.node.specifiers;
+    var defaultSpecifier = specifiers === null || specifiers === void 0 ? void 0 : specifiers.find(function (specifier) {
+      return specifier.type === 'ImportDefaultSpecifier';
+    });
+    if (defaultSpecifier && defaultSpecifier.local) {
+      var defaultButtonImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier(defaultSpecifier.local.name))], j.stringLiteral(entryPointsMapping.Button));
+      j(node).insertAfter(defaultButtonImport);
+    }
+    var defaultTypeSpecifiers = specifiers === null || specifiers === void 0 ? void 0 : specifiers.filter(function (specifier) {
+      return specifier.importKind === 'type';
+    });
+    if (defaultTypeSpecifiers !== null && defaultTypeSpecifiers !== void 0 && defaultTypeSpecifiers.length) {
+      var typeImport = j.importDeclaration(defaultTypeSpecifiers, j.stringLiteral('@atlaskit/button/types'));
+      j(node).insertAfter(typeImport);
+    }
+    var valueSpecifiers = specifiers === null || specifiers === void 0 ? void 0 : specifiers.filter(function (specifier) {
+      return specifier.type === 'ImportSpecifier';
+    });
+    var otherTypeSpecifiers = valueSpecifiers === null || valueSpecifiers === void 0 ? void 0 : valueSpecifiers.filter(function (specifier) {
+      return BUTTON_TYPES.includes(specifier.imported.name);
+    });
+    if (otherTypeSpecifiers !== null && otherTypeSpecifiers !== void 0 && otherTypeSpecifiers.length) {
+      var _typeImport = j.importDeclaration(otherTypeSpecifiers, j.stringLiteral('@atlaskit/button'));
+      j(node).insertAfter(_typeImport);
+    }
+    if (valueSpecifiers !== null && valueSpecifiers !== void 0 && valueSpecifiers.length) {
+      valueSpecifiers.forEach(function (specifier) {
+        if (specifier.local && specifier.type === 'ImportSpecifier' && specifier.local.name && entryPointsMapping[specifier.imported.name]) {
+          var newImport = j.importDeclaration([j.importDefaultSpecifier(j.identifier(specifier.local.name))], j.stringLiteral(entryPointsMapping[specifier.imported.name]));
+          j(node).insertAfter(newImport);
+        }
+      });
+    }
+    j(node).remove();
+  });
+  return fileSource.toSource(PRINT_SETTINGS);
+};
+export default transformer;

package/dist/esm/presets/migrate-to-new-buttons/migrate-to-new-buttons.js

@@ -0,0 +1,38 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import splitImportsTransformer from './codemods/next-split-imports';
+import migrateToNewButtonVariantsTransformer from './codemods/next-migrate-to-new-button-variants';
+export default function transformer(_x, _x2) {
+  return _transformer.apply(this, arguments);
+}
+function _transformer() {
+  _transformer = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(file, api) {
+    var transformers, src;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          transformers = [splitImportsTransformer, migrateToNewButtonVariantsTransformer];
+          src = file.source;
+          transformers.forEach(function (transformer) {
+            if (typeof src === 'undefined') {
+              return;
+            }
+            var nextSrc = transformer(_objectSpread(_objectSpread({}, file), {}, {
+              source: src
+            }), api);
+            if (nextSrc) {
+              src = nextSrc;
+            }
+          });
+          return _context.abrupt("return", src);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _transformer.apply(this, arguments);
+}

package/dist/esm/presets/migrate-to-new-buttons/utils/constants.js

@@ -0,0 +1,29 @@
+export var PRINT_SETTINGS = {
+  quote: 'single'
+};
+export var NEW_BUTTON_VARIANTS = {
+  default: {
+    import: 'UNSAFE_BUTTON',
+    as: 'Button'
+  },
+  link: {
+    import: 'UNSAFE_LINK_BUTTON',
+    as: 'LinkButton'
+  },
+  icon: {
+    import: 'UNSAFE_ICON_BUTTON',
+    as: 'IconButton'
+  },
+  linkIcon: {
+    import: 'UNSAFE_LINK_ICON_BUTTON',
+    as: 'LinkIconButton'
+  }
+};
+export var NEW_BUTTON_ENTRY_POINT = '@atlaskit/button/unsafe';
+export var entryPointsMapping = {
+  Button: '@atlaskit/button/standard-button',
+  LoadingButton: '@atlaskit/button/loading-button',
+  ButtonGroup: '@atlaskit/button/button-group',
+  CustomThemeButton: '@atlaskit/button/custom-theme-button'
+};
+export var BUTTON_TYPES = ['Appearance', 'Spacing', 'BaseOwnProps', 'BaseProps', 'ButtonProps', 'LoadingButtonProps', 'LoadingButtonOwnProps', 'ThemeTokens', 'ThemeProps', 'InteractionState', 'CustomThemeButtonProps', 'CustomThemeButtonOwnProps'];

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

@@ -332,8 +332,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 (isParentOfToken(j, path)) {

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

@@ -1,9 +1,9 @@
-import { isColorProperty } from '../../css-to-design-tokens/css-to-design-tokens';
+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 (isColorProperty(match[1])) {
+    if (isColorRelatedProperty(match[1])) {
       return true;
     }
   }

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,3 +1,2 @@
 import { FileInfo } from 'jscodeshift';
-export declare function isColorProperty(prop: string): boolean;
 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/index.d.ts

@@ -6,5 +6,6 @@ import './styled-to-emotion/styled-to-emotion';
 import './theme-to-design-tokens/theme-to-design-tokens';
 import './theme-remove-deprecated-mixins/theme-remove-deprecated-mixins';
 import './css-to-design-tokens/css-to-design-tokens';
+import './migrate-to-new-buttons/migrate-to-new-buttons';
 declare const presets: string[];
 export default presets;

package/dist/types/presets/migrate-to-new-buttons/codemods/next-migrate-to-new-button-variants.d.ts

@@ -0,0 +1,3 @@
+import type { API, FileInfo } from 'jscodeshift';
+declare const transformer: (file: FileInfo, api: API) => string;
+export default transformer;

package/dist/types/presets/migrate-to-new-buttons/codemods/next-split-imports.d.ts

@@ -0,0 +1,3 @@
+import type { API, FileInfo } from 'jscodeshift';
+declare const transformer: (file: FileInfo, api: API) => string;
+export default transformer;

package/dist/types/presets/migrate-to-new-buttons/migrate-to-new-buttons.d.ts

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

package/dist/types/presets/migrate-to-new-buttons/utils/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const PRINT_SETTINGS: {
+    quote: "single";
+};
+export declare const NEW_BUTTON_VARIANTS: {
+    [key: string]: {
+        import: string;
+        as: string;
+    };
+};
+export declare const NEW_BUTTON_ENTRY_POINT = "@atlaskit/button/unsafe";
+export declare const entryPointsMapping: {
+    [key: string]: string;
+};
+export declare const BUTTON_TYPES: string[];

package/dist/types-ts4.5/main.d.ts

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

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

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

package/dist/types-ts4.5/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;