@atlaskit/eslint-plugin-design-system 8.33.0 → 8.36.0

package/dist/cjs/rules/use-primitives-text/transformers/emphasis-elements.js

@@ -36,7 +36,8 @@ var EmphasisElements = exports.EmphasisElements = {
       suggest: [{
         desc: "Convert to Text",
         fix: EmphasisElements._fix(node, {
-          context: context
+          context: context,
+          config: config
         })
       }]
     });
@@ -65,7 +66,8 @@ var EmphasisElements = exports.EmphasisElements = {
     return true;
   },
   _fix: function _fix(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = (0, _upsertImportDeclaration.upsertImportDeclaration)({
         module: '@atlaskit/primitives',
@@ -73,8 +75,9 @@ var EmphasisElements = exports.EmphasisElements = {
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
       var asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'em', fixer);
+      var colorAttributeFix = (0, _common.addColorInheritAttributeFix)(node, config, fixer);
       var testAttributeFix = (0, _common.updateTestIdAttributeFix)(node, fixer);
-      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [asAttributeFix, testAttributeFix]).filter(function (fix) {
+      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };

package/dist/cjs/rules/use-primitives-text/transformers/paragraph-elements.js

@@ -53,6 +53,7 @@ var ParagraphElements = exports.ParagraphElements = {
           desc: 'Convert to Text and Stack',
           fix: ParagraphElements._fixMultiple(node, {
             context: context,
+            config: config,
             refs: refs
           })
         }]
@@ -64,7 +65,8 @@ var ParagraphElements = exports.ParagraphElements = {
         suggest: [{
           desc: 'Convert to Text',
           fix: ParagraphElements._fixSingle(node, {
-            context: context
+            context: context,
+            config: config
           })
         }]
       });
@@ -130,6 +132,13 @@ var ParagraphElements = exports.ParagraphElements = {
           }
         };
       }
+    } else if (!ast.JSXElement.hasAllowedAttrsOnly(node, _common.allowedAttrs)) {
+      return {
+        success: false,
+        refs: {
+          siblings: siblings
+        }
+      };
     }
     var importDeclaration = ast.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/primitives');
 
@@ -150,21 +159,25 @@ var ParagraphElements = exports.ParagraphElements = {
     };
   },
   _fixSingle: function _fixSingle(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = (0, _upsertImportDeclaration.upsertImportDeclaration)({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
+      var asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'p', fixer);
+      var colorAttributeFix = (0, _common.addColorInheritAttributeFix)(node, config, fixer);
       var testAttributeFix = (0, _common.updateTestIdAttributeFix)(node, fixer);
-      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [testAttributeFix]).filter(function (fix) {
+      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };
   },
   _fixMultiple: function _fixMultiple(node, _ref4) {
     var context = _ref4.context,
+      config = _ref4.config,
       refs = _ref4.refs;
     return function (fixer) {
       if (!(0, _eslintCodemodUtils.isNodeOfType)(node.parent, 'JSXElement') || !node.parent.closingElement) {
@@ -179,8 +192,10 @@ var ParagraphElements = exports.ParagraphElements = {
       var siblingFixes = refs.siblings.map(function (sibling) {
         if ((0, _eslintCodemodUtils.isNodeOfType)(sibling, 'JSXElement')) {
           var elementNameFixes = ast.JSXElement.updateName(sibling, 'Text', fixer);
+          var asAttributeFix = ast.JSXElement.addAttribute(sibling, 'as', 'p', fixer);
+          var colorAttributeFix = (0, _common.addColorInheritAttributeFix)(sibling, config, fixer);
           var testAttributeFix = (0, _common.updateTestIdAttributeFix)(sibling, fixer);
-          return [].concat((0, _toConsumableArray2.default)(elementNameFixes), [testAttributeFix]);
+          return [].concat((0, _toConsumableArray2.default)(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]);
         }
         return undefined;
       }).flat();

package/dist/cjs/rules/use-primitives-text/transformers/span-elements.js

@@ -36,7 +36,8 @@ var SpanElements = exports.SpanElements = {
       suggest: [{
         desc: "Convert to Text",
         fix: SpanElements._fix(node, {
-          context: context
+          context: context,
+          config: config
         })
       }]
     });
@@ -70,16 +71,17 @@ var SpanElements = exports.SpanElements = {
     return true;
   },
   _fix: function _fix(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = (0, _upsertImportDeclaration.upsertImportDeclaration)({
         module: '@atlaskit/primitives',
         specifiers: ['Text']
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
-      var variantAttributeFix = ast.JSXElement.addAttribute(node, 'variant', 'ui', fixer);
+      var colorAttributeFix = (0, _common.addColorInheritAttributeFix)(node, config, fixer);
       var testAttributeFix = (0, _common.updateTestIdAttributeFix)(node, fixer);
-      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [variantAttributeFix, testAttributeFix]).filter(function (fix) {
+      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };

package/dist/cjs/rules/use-primitives-text/transformers/strong-elements.js

@@ -36,7 +36,8 @@ var StrongElements = exports.StrongElements = {
       suggest: [{
         desc: "Convert to Text",
         fix: StrongElements._fix(node, {
-          context: context
+          context: context,
+          config: config
         })
       }]
     });
@@ -65,7 +66,8 @@ var StrongElements = exports.StrongElements = {
     return true;
   },
   _fix: function _fix(node, _ref3) {
-    var context = _ref3.context;
+    var context = _ref3.context,
+      config = _ref3.config;
     return function (fixer) {
       var importFix = (0, _upsertImportDeclaration.upsertImportDeclaration)({
         module: '@atlaskit/primitives',
@@ -73,8 +75,9 @@ var StrongElements = exports.StrongElements = {
       }, context, fixer);
       var elementNameFixes = ast.JSXElement.updateName(node, 'Text', fixer);
       var asAttributeFix = ast.JSXElement.addAttribute(node, 'as', 'strong', fixer);
+      var colorAttributeFix = (0, _common.addColorInheritAttributeFix)(node, config, fixer);
       var testAttributeFix = (0, _common.updateTestIdAttributeFix)(node, fixer);
-      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [asAttributeFix, testAttributeFix]).filter(function (fix) {
+      return [importFix].concat((0, _toConsumableArray2.default)(elementNameFixes), [asAttributeFix, colorAttributeFix, testAttributeFix]).filter(function (fix) {
         return Boolean(fix);
       }); // Some of the transformers can return arrays with undefined, so filter them out
     };

package/dist/cjs/rules/use-tokens-typography/config/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ruleSchema = exports.getConfig = void 0;
+var ruleSchema = exports.ruleSchema = {
+  type: 'array',
+  items: {
+    type: 'object',
+    properties: {
+      failSilently: {
+        type: 'boolean'
+      }
+    }
+  }
+};
+var defaultConfig = {
+  failSilently: false
+};
+var getConfig = exports.getConfig = function getConfig(overrides) {
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+  // start with an empty object, then merge in the defaults, then merge in overrides.
+  // The empty object is returned, as well as modified in place
+  return Object.assign({}, defaultConfig, overrides);
+};

package/dist/cjs/rules/use-tokens-typography/error-boundary.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorBoundary = void 0;
+/**
+ * ESLint rules should NEVER throw exceptions, because that breaks the VSCode ESLint server
+ * (and probably the IntelliJ one too), which causes linting to fail in a file.
+ *
+ * It also breaks CI, which was the reason this error boundary was added. It's a final
+ * catch all.
+ */
+var errorBoundary = exports.errorBoundary = function errorBoundary(func, _ref) {
+  var config = _ref.config;
+  try {
+    func();
+  } catch (err) {
+    if (!config.failSilently) {
+      // eslint-disable-next-line no-console
+      console.warn(err);
+    }
+  }
+};

package/dist/cjs/rules/use-tokens-typography/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _createRule = require("../utils/create-rule");
+var _config = require("./config");
+var _errorBoundary = require("./error-boundary");
+var _styleObject = require("./transformers/style-object");
+var create = function create(context) {
+  var config = (0, _config.getConfig)(context.options[0]);
+  return {
+    // const styles = css({ fontSize: '14px, ... }), styled.div({ fontSize: 14, ... })
+    ObjectExpression: function ObjectExpression(node) {
+      return (0, _errorBoundary.errorBoundary)(function () {
+        return _styleObject.StyleObject.lint(node, {
+          context: context
+        });
+      }, {
+        config: config
+      });
+    }
+  };
+};
+var rule = (0, _createRule.createLintRule)({
+  meta: {
+    name: 'use-tokens-typography',
+    type: 'problem',
+    fixable: 'code',
+    hasSuggestions: true,
+    docs: {
+      description: 'Enforces usage of design tokens for typography properties rather than hard-coded values.',
+      recommended: false,
+      severity: 'warn'
+    },
+    messages: {
+      noRawTypographyValues: 'Typography primitives or tokens should be used instead of hard-coded values.\n\n@meta <<{{payload}}>>.'
+    },
+    schema: _config.ruleSchema
+  },
+  create: create
+});
+var _default = exports.default = rule;

package/dist/cjs/rules/use-tokens-typography/transformers/style-object.js

@@ -0,0 +1,212 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StyleObject = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var _astNodes = require("../../../ast-nodes");
+var _utils = require("../../ensure-design-token-usage/utils");
+var _isNode = require("../../utils/is-node");
+var _utils2 = require("../utils");
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+var StyleObject = exports.StyleObject = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context;
+    // To force the correct node type
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'ObjectExpression')) {
+      return {
+        success: false
+      };
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    var _StyleObject$_check = StyleObject._check(node, {
+        context: context
+      }),
+      success = _StyleObject$_check.success,
+      refs = _StyleObject$_check.refs;
+    if (!success || !refs) {
+      return;
+    }
+    var fontSizeNode = refs.fontSizeNode,
+      fontSizeRaw = refs.fontSizeRaw,
+      tokensImportNode = refs.tokensImportNode;
+    var fontSizeValue = (0, _utils.normaliseValue)('fontSize', fontSizeRaw);
+
+    // -- Font weight --
+    var fontWeightNode = _astNodes.Object.getEntryByPropertyName(node, 'fontWeight');
+    var fontWeightRaw = fontWeightNode && (0, _utils.getValueForPropertyNode)(fontWeightNode, context);
+
+    // If no fontWeight value exists, default to 400 to avoid matching with a bolder token resulting in a visual change
+    var fontWeightValue = fontWeightRaw && (0, _utils.normaliseValue)('fontWeight', fontWeightRaw) || _utils2.defaultFontWeight;
+    fontWeightValue = fontWeightValue.length === 3 ? fontWeightValue : _utils2.fontWeightMap[fontWeightValue] || _utils2.defaultFontWeight;
+
+    // -- Line height --
+    var lineHeightNode = _astNodes.Object.getEntryByPropertyName(node, 'lineHeight');
+    var lineHeightRaw = lineHeightNode && (0, _utils.getValueForPropertyNode)(lineHeightNode, context);
+    var shouldAddFontWeight = false;
+    var lineHeightValue = lineHeightRaw && (0, _utils.normaliseValue)('lineHeight', lineHeightRaw) || undefined;
+    if (lineHeightValue === fontSizeValue) {
+      lineHeightValue = '1';
+    }
+
+    // -- Match tokens --
+    var matchingTokens = (0, _utils2.findTypographyTokenForValues)(fontSizeValue, lineHeightValue);
+    if (matchingTokens.length) {
+      // If we have multiple matching tokens, try matching fontWeight
+      var matchingTokensWithWeight = matchingTokens.filter(function (token) {
+        return fontWeightValue ? token.values.fontWeight === fontWeightValue : token;
+      });
+      if (matchingTokensWithWeight.length) {
+        // Possibly narrowed down tokens
+        matchingTokens = matchingTokensWithWeight;
+      } else {
+        // Ended up with 0 matches by matching fontWeight
+        // return body token and add fontWeight manually
+        matchingTokens = matchingTokens.filter(function (token) {
+          return token.tokenName.includes('.body');
+        });
+        shouldAddFontWeight = true;
+      }
+    }
+
+    // Get other font-* nodes that we can replace/remove.
+    // These aren't needed for token matching.
+
+    // -- Font family --
+    var fontFamilyNode = _astNodes.Object.getEntryByPropertyName(node, 'fontFamily');
+    var fontFamilyRaw = fontFamilyNode && (0, _utils.getValueForPropertyNode)(fontFamilyNode, context);
+    var fontFamilyValue = fontFamilyRaw && (0, _utils.normaliseValue)('fontFamily', fontFamilyRaw) || undefined;
+    var fontFamilyToAdd;
+    // If font family uses the Charlie font we can't replace; exit
+    if (fontFamilyValue) {
+      if (fontFamilyValue.toLowerCase().includes('charlie display')) {
+        fontFamilyToAdd = 'heading';
+      } else if (fontFamilyValue.toLowerCase().includes('charlie text')) {
+        fontFamilyToAdd = 'body';
+      }
+    } else {
+      // Font family node exists but we can't resolve its value
+      // Will need to re-add it below the font property to ensure it still applies
+      fontFamilyToAdd = fontFamilyNode ? 'original' : undefined;
+    }
+
+    // -- Font style --
+    var fontStyleNode = _astNodes.Object.getEntryByPropertyName(node, 'fontStyle');
+    var fontStyleRaw = fontStyleNode && (0, _utils.getValueForPropertyNode)(fontStyleNode, context);
+    var fontStyleValue = fontStyleRaw && (0, _utils.normaliseValue)('fontStyle', fontStyleRaw) || undefined;
+    var fontStyleToAdd;
+    if (fontStyleValue === 'italic') {
+      fontStyleToAdd = 'italic';
+    }
+
+    // -- Letter spacing --
+    var letterSpacingNode = _astNodes.Object.getEntryByPropertyName(node, 'letterSpacing');
+
+    // A single matching token
+    // TOOD: Maybe suggest options if > 1 matching token
+    if (matchingTokens.length === 1) {
+      var matchingToken = matchingTokens[0];
+
+      // fontSize node is always first
+      var nodesToReplace = [fontSizeNode, fontWeightNode, lineHeightNode, fontFamilyNode, fontStyleNode, letterSpacingNode].filter(_utils2.notUndefined);
+      var fontFamilyTokenName = fontFamilyToAdd ? "font.family.brand.".concat(fontFamilyToAdd) : '';
+      var fontWeightReplacementToken = shouldAddFontWeight ? (0, _utils2.findFontWeightTokenForValue)(fontWeightValue) : undefined;
+      var fontWeightReplacement = fontWeightReplacementToken && (0, _utils2.getTokenProperty)('fontWeight', fontWeightReplacementToken.tokenName, fontWeightValue);
+      var fontFamilyReplacement = fontFamilyToAdd && (fontFamilyToAdd === 'original' ? (0, _utils2.convertPropertyNodeToStringableNode)(
+      // This will always exist if fontFamilyToAdd === 'original', TS can't figure that out.
+      fontFamilyNode) : (0, _utils2.getTokenProperty)('fontFamily', fontFamilyTokenName, (0, _utils2.findFontFamilyValueForToken)(fontFamilyTokenName)));
+      var fontStyleReplacement = fontStyleToAdd && (0, _utils2.getLiteralProperty)('fontStyle', fontStyleToAdd);
+      var fixerRefs = {
+        matchingToken: matchingToken,
+        nodesToReplace: nodesToReplace,
+        tokensImportNode: tokensImportNode,
+        fontWeightReplacement: fontWeightReplacement,
+        fontFamilyReplacement: fontFamilyReplacement,
+        fontStyleReplacement: fontStyleReplacement
+      };
+      context.report({
+        node: fontSizeNode,
+        messageId: 'noRawTypographyValues',
+        data: {
+          payload: "fontSize:".concat(fontSizeRaw)
+        },
+        fix: StyleObject._fix(fixerRefs, context)
+      });
+    } else if (!matchingTokens.length) {
+      context.report({
+        node: fontSizeNode,
+        messageId: 'noRawTypographyValues',
+        data: {
+          payload: "fontSize:".concat(fontSizeRaw)
+        }
+      });
+    }
+    return;
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context;
+    if (!(0, _isNode.isDecendantOfStyleBlock)(node) && !(0, _isNode.isDecendantOfType)(node, 'JSXExpressionContainer')) {
+      return {
+        success: false
+      };
+    }
+
+    // -- Font size --
+    var fontSizeNode = _astNodes.Object.getEntryByPropertyName(node, 'fontSize');
+    if (!fontSizeNode || !(0, _utils2.isValidPropertyNode)(fontSizeNode) || (0, _isNode.isDecendantOfGlobalToken)(fontSizeNode.value)) {
+      return {
+        success: false
+      };
+    }
+    var fontSizeRaw = (0, _utils.getValueForPropertyNode)(fontSizeNode, context);
+
+    // Without a valid fontSize value we can't be certain what token should be used; exit
+    if (!fontSizeRaw) {
+      return {
+        success: false
+      };
+    }
+    var importDeclaration = _astNodes.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/tokens');
+
+    // If there is more than one `@atlaskit/tokens` import, then it becomes difficult to determine which import to transform
+    if (importDeclaration.length > 1) {
+      return {
+        success: false
+      };
+    }
+    return {
+      success: true,
+      refs: {
+        fontSizeNode: fontSizeNode,
+        fontSizeRaw: fontSizeRaw,
+        tokensImportNode: importDeclaration[0]
+      }
+    };
+  },
+  _fix: function _fix(refs, context) {
+    return function (fixer) {
+      var matchingToken = refs.matchingToken,
+        nodesToReplace = refs.nodesToReplace,
+        tokensImportNode = refs.tokensImportNode,
+        fontWeightReplacement = refs.fontWeightReplacement,
+        fontFamilyReplacement = refs.fontFamilyReplacement,
+        fontStyleReplacement = refs.fontStyleReplacement;
+      var fontSizeNode = nodesToReplace[0];
+      return (!tokensImportNode ? [(0, _utils.insertTokensImport)(fixer)] : []).concat(nodesToReplace.map(function (node, index) {
+        // Replace first node with token, delete remaining nodes. Guaranteed to be fontSize
+        if (index === 0) {
+          return fixer.replaceText(node, "".concat((0, _utils2.getTokenProperty)('font', matchingToken.tokenName, matchingToken.tokenValue)));
+        }
+
+        // We don't replace fontWeight/fontFamily/fontStyle here in case it occurs before the font property.
+        // Instead delete the original property and add below
+        return _astNodes.ObjectEntry.deleteEntry(node, context, fixer);
+      }),
+      // Make sure font weight/family/style properties are added AFTER font property to ensure they override corectly
+      fontWeightReplacement ? [fixer.insertTextAfter(fontSizeNode, ",\n".concat(fontWeightReplacement))] : [], fontFamilyReplacement ? [fixer.insertTextAfter(fontSizeNode, ",\n".concat(fontFamilyReplacement))] : [], fontStyleReplacement ? [fixer.insertTextAfter(fontSizeNode, ",\n".concat(fontStyleReplacement))] : []);
+    };
+  }
+};

package/dist/cjs/rules/use-tokens-typography/utils.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertPropertyNodeToStringableNode = convertPropertyNodeToStringableNode;
+exports.defaultFontWeight = void 0;
+exports.findFontFamilyValueForToken = findFontFamilyValueForToken;
+exports.findFontWeightTokenForValue = findFontWeightTokenForValue;
+exports.findTypographyTokenForValues = findTypographyTokenForValues;
+exports.fontWeightTokens = exports.fontWeightMap = exports.fontFamilyTokens = void 0;
+exports.getLiteralProperty = getLiteralProperty;
+exports.getTokenProperty = getTokenProperty;
+exports.isTypographyProperty = exports.isFontSizeSmall = exports.isFontSize = exports.isFontFamily = exports.isCodeFontFamily = void 0;
+exports.isValidPropertyNode = isValidPropertyNode;
+exports.notUndefined = notUndefined;
+exports.typographyValueToToken = exports.typographyProperties = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var _palettesRaw = require("@atlaskit/tokens/palettes-raw");
+var _tokensRaw = require("@atlaskit/tokens/tokens-raw");
+var typographyProperties = exports.typographyProperties = ['fontSize', 'fontWeight', 'fontFamily', 'lineHeight'];
+var isTypographyProperty = exports.isTypographyProperty = function isTypographyProperty(propertyName) {
+  return typographyProperties.includes(propertyName);
+};
+var isFontSize = exports.isFontSize = function isFontSize(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
+};
+var isFontSizeSmall = exports.isFontSizeSmall = function isFontSizeSmall(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
+};
+var isFontFamily = exports.isFontFamily = function isFontFamily(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && (node.callee.name === 'fontFamily' || node.callee.name === 'getFontFamily');
+};
+var isCodeFontFamily = exports.isCodeFontFamily = function isCodeFontFamily(node) {
+  return (0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression') && (0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier') && (node.callee.name === 'codeFontFamily' || node.callee.name === 'getCodeFontFamily');
+};
+var typographyValueToToken = exports.typographyValueToToken = _tokensRaw.typographyAdg3
+// we're filtering here to remove the `font` tokens.
+.filter(function (t) {
+  return t.attributes.group === 'typography';
+}).filter(function (t) {
+  return t.cleanName.includes('font.heading') || t.cleanName.includes('font.body');
+}).map(function (currentToken) {
+  var _typographyPalette$fi, _typographyPalette$fi2, _typographyPalette$fi3;
+  var individualValues = {
+    fontSize: (_typographyPalette$fi = _palettesRaw.typographyPalette.find(function (baseToken) {
+      return baseToken.path.slice(-1)[0] ===
+      // @ts-expect-error token.original.value can be a string, due to the typographyTokens export including deprecated tokens
+      currentToken.original.value.fontSize;
+    })) === null || _typographyPalette$fi === void 0 ? void 0 : _typographyPalette$fi.value,
+    fontWeight: (_typographyPalette$fi2 = _palettesRaw.typographyPalette.find(function (baseToken) {
+      return baseToken.path.slice(-1)[0] ===
+      // @ts-expect-error token.original.value can be a string, due to the typographyTokens export including deprecated tokens
+      currentToken.original.value.fontWeight;
+    })) === null || _typographyPalette$fi2 === void 0 ? void 0 : _typographyPalette$fi2.value,
+    lineHeight: (_typographyPalette$fi3 = _palettesRaw.typographyPalette.find(function (baseToken) {
+      return baseToken.path.slice(-1)[0] ===
+      // @ts-expect-error token.original.value can be a string, due to the typographyTokens export including deprecated tokens
+      currentToken.original.value.lineHeight;
+    })) === null || _typographyPalette$fi3 === void 0 ? void 0 : _typographyPalette$fi3.value
+  };
+  return {
+    tokenName: currentToken.cleanName,
+    tokenValue: currentToken.value,
+    values: individualValues
+  };
+});
+function findTypographyTokenForValues(fontSize, lineHeight) {
+  var matchingTokens = typographyValueToToken.filter(function (token) {
+    return token.values.fontSize === fontSize;
+  })
+  // If lineHeight == 1, we don't match to a token
+  .filter(function () {
+    return lineHeight === '1' ? false : true;
+  });
+  return matchingTokens;
+}
+var fontWeightTokens = exports.fontWeightTokens = _tokensRaw.typographyAdg3.filter(function (token) {
+  return token.attributes.group === 'fontWeight';
+}).map(function (token) {
+  return {
+    tokenName: token.cleanName,
+    tokenValue: token.value,
+    values: {}
+  };
+});
+function findFontWeightTokenForValue(fontWeight) {
+  return fontWeightTokens.find(function (token) {
+    return token.tokenValue === fontWeight;
+  });
+}
+var fontWeightMap = exports.fontWeightMap = {
+  regular: '400',
+  medium: '500',
+  semibold: '600',
+  bold: '700'
+};
+var defaultFontWeight = exports.defaultFontWeight = fontWeightMap.regular;
+var fontFamilyTokens = exports.fontFamilyTokens = _tokensRaw.typographyAdg3.filter(function (token) {
+  return token.attributes.group === 'fontFamily';
+});
+function findFontFamilyValueForToken(tokenName) {
+  var _fontFamilyTokens$fin;
+  // Note this will only ever be undefined if the tokens get renamed, and should never happen.
+  return ((_fontFamilyTokens$fin = fontFamilyTokens.find(function (token) {
+    return token.cleanName === tokenName;
+  })) === null || _fontFamilyTokens$fin === void 0 ? void 0 : _fontFamilyTokens$fin.value) || '';
+}
+function notUndefined(value) {
+  return value !== undefined;
+}
+function isValidPropertyNode(node) {
+  if (!(0, _eslintCodemodUtils.isNodeOfType)(node.key, 'Identifier') && !(0, _eslintCodemodUtils.isNodeOfType)(node.key, 'Literal')) {
+    return false;
+  }
+  return true;
+}
+function getTokenNode(tokenName, tokenValue) {
+  return (0, _eslintCodemodUtils.callExpression)({
+    callee: (0, _eslintCodemodUtils.identifier)({
+      name: 'token'
+    }),
+    arguments: [(0, _eslintCodemodUtils.literal)({
+      value: "'".concat(tokenName, "'")
+    }), (0, _eslintCodemodUtils.literal)(tokenValue)],
+    optional: false
+  });
+}
+function getTokenProperty(propertyName, tokenName, tokenFallback) {
+  return (0, _eslintCodemodUtils.property)({
+    key: (0, _eslintCodemodUtils.identifier)(propertyName),
+    value: getTokenNode(tokenName, tokenFallback)
+  });
+}
+function getLiteralProperty(propertyName, propertyValue) {
+  return (0, _eslintCodemodUtils.property)({
+    key: (0, _eslintCodemodUtils.identifier)(propertyName),
+    value: (0, _eslintCodemodUtils.literal)(propertyValue)
+  });
+}
+function convertPropertyNodeToStringableNode(node) {
+  return (0, _eslintCodemodUtils.property)({
+    key: node.key,
+    value: node.value
+  });
+}

package/dist/es2019/ast-nodes/index.js

@@ -3,4 +3,5 @@ export { Import } from './import';
 export { JSXAttribute } from './jsx-attribute';
 export { JSXElement } from './jsx-element';
 export { Object } from './object';
+export { ObjectEntry } from './object-entry';
 export { Root } from './root';

package/dist/es2019/ast-nodes/object-entry.js

@@ -0,0 +1,22 @@
+const ObjectEntry = {
+  deleteEntry(node, context, fixer) {
+    var _lastToken;
+    // context.getSourceCode() is deprecated in favour of context.sourceCode, however this returns undefined for some reason
+    const sourceCode = context.getSourceCode();
+
+    // fixer.remove() doesn't account for things like commas or newlines within an ObjectExpression and will result in invalid output.
+    // This approach specifically removes the node and trailing comma, and should work for single- and multi-line objects.
+    // From https://github.com/eslint/eslint/issues/9576#issuecomment-341737453
+    let prevToken = sourceCode.getTokenBefore(node);
+    while (((_prevToken = prevToken) === null || _prevToken === void 0 ? void 0 : _prevToken.value) !== ',' && ((_prevToken2 = prevToken) === null || _prevToken2 === void 0 ? void 0 : _prevToken2.value) !== '{') {
+      var _prevToken, _prevToken2;
+      prevToken = sourceCode.getTokenBefore(node);
+    }
+    let lastToken = sourceCode.getTokenAfter(node);
+    if (((_lastToken = lastToken) === null || _lastToken === void 0 ? void 0 : _lastToken.value) !== ',') {
+      lastToken = sourceCode.getTokenBefore(lastToken);
+    }
+    return fixer.removeRange([prevToken.range[1], lastToken.range[1]]);
+  }
+};
+export { ObjectEntry };

package/dist/es2019/ast-nodes/object.js

@@ -27,7 +27,7 @@ const ASTObjectExpression = {
     });
   },
   /**
-   * Returns a key-value pair like: `padding: '8px'` from: `{ padding: '8px' }`.
+   * Returns the first Property node from an Object that matches the provided name.
    */
   getEntryByPropertyName(node, name) {
     return node.properties.find(property => {