@atlaskit/eslint-plugin-design-system 9.0.0 → 9.2.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @atlaskit/eslint-plugin-design-system
 
+## 9.2.0
+
+### Minor Changes
+
+- [#84330](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/84330) [`391be0d8e414`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/391be0d8e414) - - `prefer-primitives`: This rule is now deprecated. Please use `use-primitives` instead.
+  - `ensure-design-token-usage/preview`: This rule is now deprecated. Please use `use-tokens-space` instead.
+
+## 9.1.0
+
+### Minor Changes
+
+- [#84334](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/84334) [`b2134858ba58`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/b2134858ba58) - The `use-tokens-typography` rule now applies token fallbacks that reference the constants exported via `@atlaskit/theme/typography`, rather than applying the fallback string inline.
+
 ## 9.0.0
 
 ### Major Changes

package/dist/cjs/rules/ensure-design-token-usage-preview/index.js

@@ -6,25 +6,31 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _ensureDesignTokenUsage = require("../ensure-design-token-usage");
 var _ruleMeta = _interopRequireDefault(require("../ensure-design-token-usage/rule-meta"));
 var _createRule = require("../utils/create-rule");
 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) { (0, _defineProperty2.default)(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; }
-var defaultConfig = {
-  domains: ['spacing'],
-  applyImport: true,
-  shouldEnforceFallbacks: false
-};
 var rule = (0, _createRule.createLintRule)({
   meta: _objectSpread(_objectSpread({}, _ruleMeta.default), {}, {
     name: 'ensure-design-token-usage/preview',
+    deprecated: true,
+    replacedBy: ['@atlaskit/design-system/use-tokens-space'],
     docs: _objectSpread(_objectSpread({}, _ruleMeta.default.docs), {}, {
       description: 'Enforces usage of pre-release design tokens rather than hard-coded values.',
       recommended: false,
       severity: 'warn'
     })
   }),
-  create: (0, _ensureDesignTokenUsage.createWithConfig)(defaultConfig)
+  create: function create() {
+    /**
+     * We can't just outright delete the ESLint rule, since:
+     * ```
+     * // eslint-disable @eslint-plugin/design-system/ensure-design-token-usage/preview
+     * ```
+     * will cause CI to fail if the rule definition doesn't exist. So, instead
+     * we can change the implementation of the rule so that it never reports.
+     */
+    return {};
+  }
 });
 var _default = exports.default = rule;

package/dist/cjs/rules/prefer-primitives/index.js

@@ -4,17 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _eslintCodemodUtils = require("eslint-codemod-utils");
 var _createRule = require("../utils/create-rule");
-var _utils = require("./utils");
-// eslint-disable-next-line import/no-extraneous-dependencies
-
 var primitiveDocsUrl = 'https://go.atlassian.com/dst-prefer-primitives';
 var rule = (0, _createRule.createLintRule)({
   meta: {
     name: 'prefer-primitives',
     type: 'suggestion',
     hasSuggestions: false,
+    deprecated: true,
+    replacedBy: ['@atlaskit/design-system/use-primitives'],
     docs: {
       description: 'Increase awareness of primitive components via code hints. Strictly used for education purposes and discoverability. To enforce usage please refer to the `use-primitives` rule.',
       recommended: false,
@@ -24,84 +22,16 @@ var rule = (0, _createRule.createLintRule)({
       preferPrimitives: "This \"{{element}}\" may be able to be replaced with a primitive component. See ".concat(primitiveDocsUrl, " for guidance.")
     }
   },
-  create: function create(context) {
-    return {
-      // Look for HTML elements - <div>, <span>
-      // Look for styled calls/templates - styled.div(...), styled.span`...`
-      JSXOpeningElement: function JSXOpeningElement(node) {
-        if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXOpeningElement')) {
-          return;
-        }
-        if (!(0, _eslintCodemodUtils.isNodeOfType)(node.name, 'JSXIdentifier')) {
-          return;
-        }
-        var suggest = (0, _utils.shouldSuggest)(node === null || node === void 0 ? void 0 : node.parent);
-        if (suggest) {
-          context.report({
-            node: node,
-            messageId: 'preferPrimitives',
-            data: {
-              element: node.name.name
-            }
-          });
-        }
-      },
-      // styled.x`` | styled2.x`` | styled.div()
-      'MemberExpression[object.name="styled"],MemberExpression[object.name="styled2"]': function MemberExpressionObjectNameStyledMemberExpressionObjectNameStyled2(node) {
-        if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'MemberExpression')) {
-          return;
-        }
-
-        // styled.div``
-        if ((0, _eslintCodemodUtils.isNodeOfType)(node.property, 'Identifier')) {
-          if (_utils.validPrimitiveElements.has(node.property.name)) {
-            var styledIdentifier = node.object.name;
-            var elementName = node.property.name;
-
-            // Including the `styled.` portion in the message to help makers understand it's not just the `div` element that should be replaced
-            var reportName = "".concat(styledIdentifier, ".").concat(elementName); // styled.div
-
-            context.report({
-              node: node,
-              messageId: 'preferPrimitives',
-              data: {
-                element: reportName
-              }
-            });
-          }
-        }
-      },
-      // styled(X)``
-      'CallExpression[callee.name="styled"]': function CallExpressionCalleeNameStyled(node) {
-        if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression')) {
-          return;
-        }
-
-        // styled('div')`` - We only care about 'div'/'span', ignore extending other components
-        if ((0, _eslintCodemodUtils.isNodeOfType)(node.arguments[0], 'Literal')) {
-          var argValue = node.arguments[0].raw;
-          if (typeof argValue === 'string') {
-            var suggest = _utils.validPrimitiveElements.has(argValue.replaceAll("'", '') // argValue will have '' around the element name, strip it out for this test
-            );
-            if (suggest) {
-              var styledIdentifier = node.callee.name;
-              var elementName = argValue;
-
-              // Including the `styled()` portion in the message to help makers understand it's not just the `div` element that should be replaced
-              var reportName = "".concat(styledIdentifier, "(").concat(elementName, ")"); // styled('div')
-
-              context.report({
-                node: node,
-                messageId: 'preferPrimitives',
-                data: {
-                  element: reportName
-                }
-              });
-            }
-          }
-        }
-      }
-    };
+  create: function create() {
+    /**
+     * We can't just outright delete the ESLint rule, since:
+     * ```
+     * // eslint-disable @eslint-plugin/design-system/prefer-primitives
+     * ```
+     * will cause CI to fail if the rule definition doesn't exist. So, instead
+     * we can change the implementation of the rule so that it never reports.
+     */
+    return {};
   }
 });
 var _default = exports.default = rule;

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

@@ -32,7 +32,9 @@ var StyleObject = exports.StyleObject = {
     }
     var fontSizeNode = refs.fontSizeNode,
       fontSizeRaw = refs.fontSizeRaw,
-      tokensImportNode = refs.tokensImportNode;
+      tokensImportNode = refs.tokensImportNode,
+      themeImportNode = refs.themeImportNode,
+      shouldAddFallbackImport = refs.shouldAddFallbackImport;
     var fontSizeValue = (0, _utils.normaliseValue)('fontSize', fontSizeRaw);
 
     // -- Font weight --
@@ -123,6 +125,8 @@ var StyleObject = exports.StyleObject = {
         matchingToken: matchingToken,
         nodesToReplace: nodesToReplace,
         tokensImportNode: tokensImportNode,
+        themeImportNode: themeImportNode,
+        shouldAddFallbackImport: shouldAddFallbackImport,
         fontWeightReplacement: fontWeightReplacement,
         fontFamilyReplacement: fontFamilyReplacement,
         fontStyleReplacement: fontStyleReplacement
@@ -169,20 +173,47 @@ var StyleObject = exports.StyleObject = {
         success: false
       };
     }
-    var importDeclaration = _astNodes.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/tokens');
+    var tokensImportDeclaration = _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) {
+    if (tokensImportDeclaration.length > 1) {
       return {
         success: false
       };
     }
+
+    // This exists purely because we're not inlining the fallback values
+    // and instead referencing a `fontFallback` object that exists in @atlaskit/theme/typography.
+    // This is a temporary measure until fallbacks are no longer required
+    var shouldAddFallbackImport = 'full';
+    var themeImportDeclaration = _astNodes.Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/theme/typography');
+    if (themeImportDeclaration.length) {
+      // Import exists, check if specifier exists
+      shouldAddFallbackImport = 'specifier';
+      var fallbackImport = themeImportDeclaration[0].specifiers.find(function (specifier) {
+        // @atlaskit/theme/typography has no default export so we can safely narrow this type
+        if (!(0, _eslintCodemodUtils.isNodeOfType)(specifier, 'ImportSpecifier')) {
+          return false;
+        }
+        if (specifier.imported.name === 'fontFallback') {
+          return true;
+        }
+        return false;
+      });
+
+      // Exact import already exists, no need to add
+      if (fallbackImport) {
+        shouldAddFallbackImport = false;
+      }
+    }
     return {
       success: true,
       refs: {
         fontSizeNode: fontSizeNode,
         fontSizeRaw: fontSizeRaw,
-        tokensImportNode: importDeclaration[0]
+        tokensImportNode: tokensImportDeclaration[0],
+        themeImportNode: themeImportDeclaration[0],
+        shouldAddFallbackImport: shouldAddFallbackImport
       }
     };
   },
@@ -191,14 +222,24 @@ var StyleObject = exports.StyleObject = {
       var matchingToken = refs.matchingToken,
         nodesToReplace = refs.nodesToReplace,
         tokensImportNode = refs.tokensImportNode,
+        themeImportNode = refs.themeImportNode,
+        shouldAddFallbackImport = refs.shouldAddFallbackImport,
         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) {
+      var root = context.getSourceCode().ast.body;
+      var fallbackImport;
+      if (shouldAddFallbackImport === 'full') {
+        fallbackImport = (0, _utils2.insertFallbackImportFull)(root, fixer);
+      } else if (shouldAddFallbackImport === 'specifier') {
+        fallbackImport = (0, _utils2.insertFallbackImportSpecifier)(fixer, themeImportNode);
+      }
+      var fallbackName = (matchingToken.tokenName === 'font.body' ? 'font.body.medium' : matchingToken.tokenName).replace('font', 'fontFallback');
+      return (!tokensImportNode ? [(0, _utils2.insertTokensImport)(root, fixer)] : []).concat(fallbackImport ? [fallbackImport] : [], 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)));
+          return fixer.replaceText(node, "".concat((0, _utils2.getTokenProperty)('font', matchingToken.tokenName, fallbackName, true)));
         }
 
         // We don't replace fontWeight/fontFamily/fontStyle here in case it occurs before the font property.

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

@@ -11,6 +11,9 @@ exports.findTypographyTokenForValues = findTypographyTokenForValues;
 exports.fontWeightTokens = exports.fontWeightMap = exports.fontFamilyTokens = void 0;
 exports.getLiteralProperty = getLiteralProperty;
 exports.getTokenProperty = getTokenProperty;
+exports.insertFallbackImportFull = insertFallbackImportFull;
+exports.insertFallbackImportSpecifier = insertFallbackImportSpecifier;
+exports.insertTokensImport = insertTokensImport;
 exports.isTypographyProperty = exports.isFontSizeSmall = exports.isFontSize = exports.isFontFamily = exports.isCodeFontFamily = void 0;
 exports.isValidPropertyNode = isValidPropertyNode;
 exports.notUndefined = notUndefined;
@@ -18,6 +21,7 @@ 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 _astNodes = require("../../ast-nodes");
 var typographyProperties = exports.typographyProperties = ['fontSize', 'fontWeight', 'fontFamily', 'lineHeight'];
 var isTypographyProperty = exports.isTypographyProperty = function isTypographyProperty(propertyName) {
   return typographyProperties.includes(propertyName);
@@ -115,21 +119,38 @@ function isValidPropertyNode(node) {
   }
   return true;
 }
-function getTokenNode(tokenName, tokenValue) {
+function getTokenNode(tokenName, tokenValue, isFallbackMember) {
+  var fallback;
+  if (isFallbackMember) {
+    fallback = createMemberExpressionFromArray(tokenValue.split('.'));
+  } else {
+    fallback = (0, _eslintCodemodUtils.literal)(tokenValue);
+  }
   return (0, _eslintCodemodUtils.callExpression)({
     callee: (0, _eslintCodemodUtils.identifier)({
       name: 'token'
     }),
     arguments: [(0, _eslintCodemodUtils.literal)({
       value: "'".concat(tokenName, "'")
-    }), (0, _eslintCodemodUtils.literal)(tokenValue)],
+    }), fallback],
     optional: false
   });
 }
+function createMemberExpressionFromArray(array) {
+  if (array.length === 1) {
+    return (0, _eslintCodemodUtils.identifier)(array[0]);
+  }
+  var property = array.pop();
+  return (0, _eslintCodemodUtils.memberExpression)({
+    object: createMemberExpressionFromArray(array),
+    property: (0, _eslintCodemodUtils.identifier)(property)
+  });
+}
 function getTokenProperty(propertyName, tokenName, tokenFallback) {
+  var isFallbackMember = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   return (0, _eslintCodemodUtils.property)({
     key: (0, _eslintCodemodUtils.identifier)(propertyName),
-    value: getTokenNode(tokenName, tokenFallback)
+    value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
   });
 }
 function getLiteralProperty(propertyName, propertyValue) {
@@ -143,4 +164,19 @@ function convertPropertyNodeToStringableNode(node) {
     key: node.key,
     value: node.value
   });
+}
+function insertTokensImport(root, fixer) {
+  return _astNodes.Root.insertImport(root, {
+    module: '@atlaskit/tokens',
+    specifiers: ['token']
+  }, fixer);
+}
+function insertFallbackImportFull(root, fixer) {
+  return _astNodes.Root.insertImport(root, {
+    module: '@atlaskit/theme/typography',
+    specifiers: ['fontFallback']
+  }, fixer);
+}
+function insertFallbackImportSpecifier(fixer, themeImportNode) {
+  return _astNodes.Import.insertNamedSpecifiers(themeImportNode, ['fontFallback'], fixer);
 }

package/dist/es2019/rules/ensure-design-token-usage-preview/index.js

@@ -1,15 +1,11 @@
-import { createWithConfig } from '../ensure-design-token-usage';
 import ruleMeta from '../ensure-design-token-usage/rule-meta';
 import { createLintRule } from '../utils/create-rule';
-const defaultConfig = {
-  domains: ['spacing'],
-  applyImport: true,
-  shouldEnforceFallbacks: false
-};
 const rule = createLintRule({
   meta: {
     ...ruleMeta,
     name: 'ensure-design-token-usage/preview',
+    deprecated: true,
+    replacedBy: ['@atlaskit/design-system/use-tokens-space'],
     docs: {
       ...ruleMeta.docs,
       description: 'Enforces usage of pre-release design tokens rather than hard-coded values.',
@@ -17,6 +13,16 @@ const rule = createLintRule({
       severity: 'warn'
     }
   },
-  create: createWithConfig(defaultConfig)
+  create() {
+    /**
+     * We can't just outright delete the ESLint rule, since:
+     * ```
+     * // eslint-disable @eslint-plugin/design-system/ensure-design-token-usage/preview
+     * ```
+     * will cause CI to fail if the rule definition doesn't exist. So, instead
+     * we can change the implementation of the rule so that it never reports.
+     */
+    return {};
+  }
 });
 export default rule;

package/dist/es2019/rules/prefer-primitives/index.js

@@ -1,14 +1,12 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-
-import { isNodeOfType } from 'eslint-codemod-utils';
 import { createLintRule } from '../utils/create-rule';
-import { shouldSuggest, validPrimitiveElements } from './utils';
 const primitiveDocsUrl = 'https://go.atlassian.com/dst-prefer-primitives';
 const rule = createLintRule({
   meta: {
     name: 'prefer-primitives',
     type: 'suggestion',
     hasSuggestions: false,
+    deprecated: true,
+    replacedBy: ['@atlaskit/design-system/use-primitives'],
     docs: {
       description: 'Increase awareness of primitive components via code hints. Strictly used for education purposes and discoverability. To enforce usage please refer to the `use-primitives` rule.',
       recommended: false,
@@ -18,85 +16,16 @@ const rule = createLintRule({
       preferPrimitives: `This "{{element}}" may be able to be replaced with a primitive component. See ${primitiveDocsUrl} for guidance.`
     }
   },
-  create(context) {
-    return {
-      // Look for HTML elements - <div>, <span>
-      // Look for styled calls/templates - styled.div(...), styled.span`...`
-
-      JSXOpeningElement(node) {
-        if (!isNodeOfType(node, 'JSXOpeningElement')) {
-          return;
-        }
-        if (!isNodeOfType(node.name, 'JSXIdentifier')) {
-          return;
-        }
-        const suggest = shouldSuggest(node === null || node === void 0 ? void 0 : node.parent);
-        if (suggest) {
-          context.report({
-            node: node,
-            messageId: 'preferPrimitives',
-            data: {
-              element: node.name.name
-            }
-          });
-        }
-      },
-      // styled.x`` | styled2.x`` | styled.div()
-      'MemberExpression[object.name="styled"],MemberExpression[object.name="styled2"]': node => {
-        if (!isNodeOfType(node, 'MemberExpression')) {
-          return;
-        }
-
-        // styled.div``
-        if (isNodeOfType(node.property, 'Identifier')) {
-          if (validPrimitiveElements.has(node.property.name)) {
-            const styledIdentifier = node.object.name;
-            const elementName = node.property.name;
-
-            // Including the `styled.` portion in the message to help makers understand it's not just the `div` element that should be replaced
-            const reportName = `${styledIdentifier}.${elementName}`; // styled.div
-
-            context.report({
-              node: node,
-              messageId: 'preferPrimitives',
-              data: {
-                element: reportName
-              }
-            });
-          }
-        }
-      },
-      // styled(X)``
-      'CallExpression[callee.name="styled"]': node => {
-        if (!isNodeOfType(node, 'CallExpression')) {
-          return;
-        }
-
-        // styled('div')`` - We only care about 'div'/'span', ignore extending other components
-        if (isNodeOfType(node.arguments[0], 'Literal')) {
-          const argValue = node.arguments[0].raw;
-          if (typeof argValue === 'string') {
-            const suggest = validPrimitiveElements.has(argValue.replaceAll(`'`, '') // argValue will have '' around the element name, strip it out for this test
-            );
-            if (suggest) {
-              const styledIdentifier = node.callee.name;
-              const elementName = argValue;
-
-              // Including the `styled()` portion in the message to help makers understand it's not just the `div` element that should be replaced
-              const reportName = `${styledIdentifier}(${elementName})`; // styled('div')
-
-              context.report({
-                node: node,
-                messageId: 'preferPrimitives',
-                data: {
-                  element: reportName
-                }
-              });
-            }
-          }
-        }
-      }
-    };
+  create() {
+    /**
+     * We can't just outright delete the ESLint rule, since:
+     * ```
+     * // eslint-disable @eslint-plugin/design-system/prefer-primitives
+     * ```
+     * will cause CI to fail if the rule definition doesn't exist. So, instead
+     * we can change the implementation of the rule so that it never reports.
+     */
+    return {};
   }
 });
 export default rule;

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

@@ -2,9 +2,9 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { Object as ASTObject, ObjectEntry, Root } from '../../../ast-nodes';
-import { getValueForPropertyNode, insertTokensImport, normaliseValue } from '../../ensure-design-token-usage/utils';
+import { getValueForPropertyNode, normaliseValue } from '../../ensure-design-token-usage/utils';
 import { isDecendantOfGlobalToken, isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
-import { convertPropertyNodeToStringableNode, defaultFontWeight, findFontFamilyValueForToken, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getLiteralProperty, getTokenProperty, isValidPropertyNode, notUndefined } from '../utils';
+import { convertPropertyNodeToStringableNode, defaultFontWeight, findFontFamilyValueForToken, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getLiteralProperty, getTokenProperty, insertFallbackImportFull, insertFallbackImportSpecifier, insertTokensImport, isValidPropertyNode, notUndefined } from '../utils';
 export const StyleObject = {
   lint(node, {
     context
@@ -29,7 +29,9 @@ export const StyleObject = {
     const {
       fontSizeNode,
       fontSizeRaw,
-      tokensImportNode
+      tokensImportNode,
+      themeImportNode,
+      shouldAddFallbackImport
     } = refs;
     const fontSizeValue = normaliseValue('fontSize', fontSizeRaw);
 
@@ -117,6 +119,8 @@ export const StyleObject = {
         matchingToken,
         nodesToReplace,
         tokensImportNode,
+        themeImportNode,
+        shouldAddFallbackImport,
         fontWeightReplacement,
         fontFamilyReplacement,
         fontStyleReplacement
@@ -164,20 +168,47 @@ export const StyleObject = {
         success: false
       };
     }
-    const importDeclaration = Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/tokens');
+    const tokensImportDeclaration = 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) {
+    if (tokensImportDeclaration.length > 1) {
       return {
         success: false
       };
     }
+
+    // This exists purely because we're not inlining the fallback values
+    // and instead referencing a `fontFallback` object that exists in @atlaskit/theme/typography.
+    // This is a temporary measure until fallbacks are no longer required
+    let shouldAddFallbackImport = 'full';
+    const themeImportDeclaration = Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/theme/typography');
+    if (themeImportDeclaration.length) {
+      // Import exists, check if specifier exists
+      shouldAddFallbackImport = 'specifier';
+      const fallbackImport = themeImportDeclaration[0].specifiers.find(specifier => {
+        // @atlaskit/theme/typography has no default export so we can safely narrow this type
+        if (!isNodeOfType(specifier, 'ImportSpecifier')) {
+          return false;
+        }
+        if (specifier.imported.name === 'fontFallback') {
+          return true;
+        }
+        return false;
+      });
+
+      // Exact import already exists, no need to add
+      if (fallbackImport) {
+        shouldAddFallbackImport = false;
+      }
+    }
     return {
       success: true,
       refs: {
         fontSizeNode,
         fontSizeRaw,
-        tokensImportNode: importDeclaration[0]
+        tokensImportNode: tokensImportDeclaration[0],
+        themeImportNode: themeImportDeclaration[0],
+        shouldAddFallbackImport
       }
     };
   },
@@ -187,15 +218,25 @@ export const StyleObject = {
         matchingToken,
         nodesToReplace,
         tokensImportNode,
+        themeImportNode,
+        shouldAddFallbackImport,
         fontWeightReplacement,
         fontFamilyReplacement,
         fontStyleReplacement
       } = refs;
       const fontSizeNode = nodesToReplace[0];
-      return (!tokensImportNode ? [insertTokensImport(fixer)] : []).concat(nodesToReplace.map((node, index) => {
+      const root = context.getSourceCode().ast.body;
+      let fallbackImport;
+      if (shouldAddFallbackImport === 'full') {
+        fallbackImport = insertFallbackImportFull(root, fixer);
+      } else if (shouldAddFallbackImport === 'specifier') {
+        fallbackImport = insertFallbackImportSpecifier(fixer, themeImportNode);
+      }
+      const fallbackName = (matchingToken.tokenName === 'font.body' ? 'font.body.medium' : matchingToken.tokenName).replace('font', 'fontFallback');
+      return (!tokensImportNode ? [insertTokensImport(root, fixer)] : []).concat(fallbackImport ? [fallbackImport] : [], nodesToReplace.map((node, index) => {
         // Replace first node with token, delete remaining nodes. Guaranteed to be fontSize
         if (index === 0) {
-          return fixer.replaceText(node, `${getTokenProperty('font', matchingToken.tokenName, matchingToken.tokenValue)}`);
+          return fixer.replaceText(node, `${getTokenProperty('font', matchingToken.tokenName, fallbackName, true)}`);
         }
 
         // We don't replace fontWeight/fontFamily/fontStyle here in case it occurs before the font property.

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

@@ -1,6 +1,7 @@
-import { callExpression, identifier, isNodeOfType, literal, property } from 'eslint-codemod-utils';
+import { callExpression, identifier, isNodeOfType, literal, memberExpression, property } from 'eslint-codemod-utils';
 import { typographyPalette } from '@atlaskit/tokens/palettes-raw';
 import { typographyAdg3 as typographyTokens } from '@atlaskit/tokens/tokens-raw';
+import { Import, Root } from '../../ast-nodes';
 export const typographyProperties = ['fontSize', 'fontWeight', 'fontFamily', 'lineHeight'];
 export const isTypographyProperty = propertyName => {
   return typographyProperties.includes(propertyName);
@@ -68,21 +69,37 @@ export function isValidPropertyNode(node) {
   }
   return true;
 }
-function getTokenNode(tokenName, tokenValue) {
+function getTokenNode(tokenName, tokenValue, isFallbackMember) {
+  let fallback;
+  if (isFallbackMember) {
+    fallback = createMemberExpressionFromArray(tokenValue.split('.'));
+  } else {
+    fallback = literal(tokenValue);
+  }
   return callExpression({
     callee: identifier({
       name: 'token'
     }),
     arguments: [literal({
       value: `'${tokenName}'`
-    }), literal(tokenValue)],
+    }), fallback],
     optional: false
   });
 }
-export function getTokenProperty(propertyName, tokenName, tokenFallback) {
+function createMemberExpressionFromArray(array) {
+  if (array.length === 1) {
+    return identifier(array[0]);
+  }
+  const property = array.pop();
+  return memberExpression({
+    object: createMemberExpressionFromArray(array),
+    property: identifier(property)
+  });
+}
+export function getTokenProperty(propertyName, tokenName, tokenFallback, isFallbackMember = false) {
   return property({
     key: identifier(propertyName),
-    value: getTokenNode(tokenName, tokenFallback)
+    value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
   });
 }
 export function getLiteralProperty(propertyName, propertyValue) {
@@ -96,4 +113,19 @@ export function convertPropertyNodeToStringableNode(node) {
     key: node.key,
     value: node.value
   });
+}
+export function insertTokensImport(root, fixer) {
+  return Root.insertImport(root, {
+    module: '@atlaskit/tokens',
+    specifiers: ['token']
+  }, fixer);
+}
+export function insertFallbackImportFull(root, fixer) {
+  return Root.insertImport(root, {
+    module: '@atlaskit/theme/typography',
+    specifiers: ['fontFallback']
+  }, fixer);
+}
+export function insertFallbackImportSpecifier(fixer, themeImportNode) {
+  return Import.insertNamedSpecifiers(themeImportNode, ['fontFallback'], fixer);
 }

package/dist/esm/rules/ensure-design-token-usage-preview/index.js

@@ -1,23 +1,29 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 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 { createWithConfig } from '../ensure-design-token-usage';
 import ruleMeta from '../ensure-design-token-usage/rule-meta';
 import { createLintRule } from '../utils/create-rule';
-var defaultConfig = {
-  domains: ['spacing'],
-  applyImport: true,
-  shouldEnforceFallbacks: false
-};
 var rule = createLintRule({
   meta: _objectSpread(_objectSpread({}, ruleMeta), {}, {
     name: 'ensure-design-token-usage/preview',
+    deprecated: true,
+    replacedBy: ['@atlaskit/design-system/use-tokens-space'],
     docs: _objectSpread(_objectSpread({}, ruleMeta.docs), {}, {
       description: 'Enforces usage of pre-release design tokens rather than hard-coded values.',
       recommended: false,
       severity: 'warn'
     })
   }),
-  create: createWithConfig(defaultConfig)
+  create: function create() {
+    /**
+     * We can't just outright delete the ESLint rule, since:
+     * ```
+     * // eslint-disable @eslint-plugin/design-system/ensure-design-token-usage/preview
+     * ```
+     * will cause CI to fail if the rule definition doesn't exist. So, instead
+     * we can change the implementation of the rule so that it never reports.
+     */
+    return {};
+  }
 });
 export default rule;

package/dist/esm/rules/prefer-primitives/index.js

@@ -1,14 +1,12 @@
-// eslint-disable-next-line import/no-extraneous-dependencies
-
-import { isNodeOfType } from 'eslint-codemod-utils';
 import { createLintRule } from '../utils/create-rule';
-import { shouldSuggest, validPrimitiveElements } from './utils';
 var primitiveDocsUrl = 'https://go.atlassian.com/dst-prefer-primitives';
 var rule = createLintRule({
   meta: {
     name: 'prefer-primitives',
     type: 'suggestion',
     hasSuggestions: false,
+    deprecated: true,
+    replacedBy: ['@atlaskit/design-system/use-primitives'],
     docs: {
       description: 'Increase awareness of primitive components via code hints. Strictly used for education purposes and discoverability. To enforce usage please refer to the `use-primitives` rule.',
       recommended: false,
@@ -18,84 +16,16 @@ var rule = createLintRule({
       preferPrimitives: "This \"{{element}}\" may be able to be replaced with a primitive component. See ".concat(primitiveDocsUrl, " for guidance.")
     }
   },
-  create: function create(context) {
-    return {
-      // Look for HTML elements - <div>, <span>
-      // Look for styled calls/templates - styled.div(...), styled.span`...`
-      JSXOpeningElement: function JSXOpeningElement(node) {
-        if (!isNodeOfType(node, 'JSXOpeningElement')) {
-          return;
-        }
-        if (!isNodeOfType(node.name, 'JSXIdentifier')) {
-          return;
-        }
-        var suggest = shouldSuggest(node === null || node === void 0 ? void 0 : node.parent);
-        if (suggest) {
-          context.report({
-            node: node,
-            messageId: 'preferPrimitives',
-            data: {
-              element: node.name.name
-            }
-          });
-        }
-      },
-      // styled.x`` | styled2.x`` | styled.div()
-      'MemberExpression[object.name="styled"],MemberExpression[object.name="styled2"]': function MemberExpressionObjectNameStyledMemberExpressionObjectNameStyled2(node) {
-        if (!isNodeOfType(node, 'MemberExpression')) {
-          return;
-        }
-
-        // styled.div``
-        if (isNodeOfType(node.property, 'Identifier')) {
-          if (validPrimitiveElements.has(node.property.name)) {
-            var styledIdentifier = node.object.name;
-            var elementName = node.property.name;
-
-            // Including the `styled.` portion in the message to help makers understand it's not just the `div` element that should be replaced
-            var reportName = "".concat(styledIdentifier, ".").concat(elementName); // styled.div
-
-            context.report({
-              node: node,
-              messageId: 'preferPrimitives',
-              data: {
-                element: reportName
-              }
-            });
-          }
-        }
-      },
-      // styled(X)``
-      'CallExpression[callee.name="styled"]': function CallExpressionCalleeNameStyled(node) {
-        if (!isNodeOfType(node, 'CallExpression')) {
-          return;
-        }
-
-        // styled('div')`` - We only care about 'div'/'span', ignore extending other components
-        if (isNodeOfType(node.arguments[0], 'Literal')) {
-          var argValue = node.arguments[0].raw;
-          if (typeof argValue === 'string') {
-            var suggest = validPrimitiveElements.has(argValue.replaceAll("'", '') // argValue will have '' around the element name, strip it out for this test
-            );
-            if (suggest) {
-              var styledIdentifier = node.callee.name;
-              var elementName = argValue;
-
-              // Including the `styled()` portion in the message to help makers understand it's not just the `div` element that should be replaced
-              var reportName = "".concat(styledIdentifier, "(").concat(elementName, ")"); // styled('div')
-
-              context.report({
-                node: node,
-                messageId: 'preferPrimitives',
-                data: {
-                  element: reportName
-                }
-              });
-            }
-          }
-        }
-      }
-    };
+  create: function create() {
+    /**
+     * We can't just outright delete the ESLint rule, since:
+     * ```
+     * // eslint-disable @eslint-plugin/design-system/prefer-primitives
+     * ```
+     * will cause CI to fail if the rule definition doesn't exist. So, instead
+     * we can change the implementation of the rule so that it never reports.
+     */
+    return {};
   }
 });
 export default rule;

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

@@ -2,9 +2,9 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { Object as ASTObject, ObjectEntry, Root } from '../../../ast-nodes';
-import { getValueForPropertyNode, insertTokensImport, normaliseValue } from '../../ensure-design-token-usage/utils';
+import { getValueForPropertyNode, normaliseValue } from '../../ensure-design-token-usage/utils';
 import { isDecendantOfGlobalToken, isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
-import { convertPropertyNodeToStringableNode, defaultFontWeight, findFontFamilyValueForToken, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getLiteralProperty, getTokenProperty, isValidPropertyNode, notUndefined } from '../utils';
+import { convertPropertyNodeToStringableNode, defaultFontWeight, findFontFamilyValueForToken, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getLiteralProperty, getTokenProperty, insertFallbackImportFull, insertFallbackImportSpecifier, insertTokensImport, isValidPropertyNode, notUndefined } from '../utils';
 export var StyleObject = {
   lint: function lint(node, _ref) {
     var context = _ref.context;
@@ -26,7 +26,9 @@ export var StyleObject = {
     }
     var fontSizeNode = refs.fontSizeNode,
       fontSizeRaw = refs.fontSizeRaw,
-      tokensImportNode = refs.tokensImportNode;
+      tokensImportNode = refs.tokensImportNode,
+      themeImportNode = refs.themeImportNode,
+      shouldAddFallbackImport = refs.shouldAddFallbackImport;
     var fontSizeValue = normaliseValue('fontSize', fontSizeRaw);
 
     // -- Font weight --
@@ -117,6 +119,8 @@ export var StyleObject = {
         matchingToken: matchingToken,
         nodesToReplace: nodesToReplace,
         tokensImportNode: tokensImportNode,
+        themeImportNode: themeImportNode,
+        shouldAddFallbackImport: shouldAddFallbackImport,
         fontWeightReplacement: fontWeightReplacement,
         fontFamilyReplacement: fontFamilyReplacement,
         fontStyleReplacement: fontStyleReplacement
@@ -163,20 +167,47 @@ export var StyleObject = {
         success: false
       };
     }
-    var importDeclaration = Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/tokens');
+    var tokensImportDeclaration = 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) {
+    if (tokensImportDeclaration.length > 1) {
       return {
         success: false
       };
     }
+
+    // This exists purely because we're not inlining the fallback values
+    // and instead referencing a `fontFallback` object that exists in @atlaskit/theme/typography.
+    // This is a temporary measure until fallbacks are no longer required
+    var shouldAddFallbackImport = 'full';
+    var themeImportDeclaration = Root.findImportsByModule(context.getSourceCode().ast.body, '@atlaskit/theme/typography');
+    if (themeImportDeclaration.length) {
+      // Import exists, check if specifier exists
+      shouldAddFallbackImport = 'specifier';
+      var fallbackImport = themeImportDeclaration[0].specifiers.find(function (specifier) {
+        // @atlaskit/theme/typography has no default export so we can safely narrow this type
+        if (!isNodeOfType(specifier, 'ImportSpecifier')) {
+          return false;
+        }
+        if (specifier.imported.name === 'fontFallback') {
+          return true;
+        }
+        return false;
+      });
+
+      // Exact import already exists, no need to add
+      if (fallbackImport) {
+        shouldAddFallbackImport = false;
+      }
+    }
     return {
       success: true,
       refs: {
         fontSizeNode: fontSizeNode,
         fontSizeRaw: fontSizeRaw,
-        tokensImportNode: importDeclaration[0]
+        tokensImportNode: tokensImportDeclaration[0],
+        themeImportNode: themeImportDeclaration[0],
+        shouldAddFallbackImport: shouldAddFallbackImport
       }
     };
   },
@@ -185,14 +216,24 @@ export var StyleObject = {
       var matchingToken = refs.matchingToken,
         nodesToReplace = refs.nodesToReplace,
         tokensImportNode = refs.tokensImportNode,
+        themeImportNode = refs.themeImportNode,
+        shouldAddFallbackImport = refs.shouldAddFallbackImport,
         fontWeightReplacement = refs.fontWeightReplacement,
         fontFamilyReplacement = refs.fontFamilyReplacement,
         fontStyleReplacement = refs.fontStyleReplacement;
       var fontSizeNode = nodesToReplace[0];
-      return (!tokensImportNode ? [insertTokensImport(fixer)] : []).concat(nodesToReplace.map(function (node, index) {
+      var root = context.getSourceCode().ast.body;
+      var fallbackImport;
+      if (shouldAddFallbackImport === 'full') {
+        fallbackImport = insertFallbackImportFull(root, fixer);
+      } else if (shouldAddFallbackImport === 'specifier') {
+        fallbackImport = insertFallbackImportSpecifier(fixer, themeImportNode);
+      }
+      var fallbackName = (matchingToken.tokenName === 'font.body' ? 'font.body.medium' : matchingToken.tokenName).replace('font', 'fontFallback');
+      return (!tokensImportNode ? [insertTokensImport(root, fixer)] : []).concat(fallbackImport ? [fallbackImport] : [], 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(getTokenProperty('font', matchingToken.tokenName, matchingToken.tokenValue)));
+          return fixer.replaceText(node, "".concat(getTokenProperty('font', matchingToken.tokenName, fallbackName, true)));
         }
 
         // We don't replace fontWeight/fontFamily/fontStyle here in case it occurs before the font property.

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

@@ -1,6 +1,7 @@
-import { callExpression, identifier, isNodeOfType, literal, property } from 'eslint-codemod-utils';
+import { callExpression, identifier, isNodeOfType, literal, memberExpression, property } from 'eslint-codemod-utils';
 import { typographyPalette } from '@atlaskit/tokens/palettes-raw';
 import { typographyAdg3 as typographyTokens } from '@atlaskit/tokens/tokens-raw';
+import { Import, Root } from '../../ast-nodes';
 export var typographyProperties = ['fontSize', 'fontWeight', 'fontFamily', 'lineHeight'];
 export var isTypographyProperty = function isTypographyProperty(propertyName) {
   return typographyProperties.includes(propertyName);
@@ -98,21 +99,38 @@ export function isValidPropertyNode(node) {
   }
   return true;
 }
-function getTokenNode(tokenName, tokenValue) {
+function getTokenNode(tokenName, tokenValue, isFallbackMember) {
+  var fallback;
+  if (isFallbackMember) {
+    fallback = createMemberExpressionFromArray(tokenValue.split('.'));
+  } else {
+    fallback = literal(tokenValue);
+  }
   return callExpression({
     callee: identifier({
       name: 'token'
     }),
     arguments: [literal({
       value: "'".concat(tokenName, "'")
-    }), literal(tokenValue)],
+    }), fallback],
     optional: false
   });
 }
+function createMemberExpressionFromArray(array) {
+  if (array.length === 1) {
+    return identifier(array[0]);
+  }
+  var property = array.pop();
+  return memberExpression({
+    object: createMemberExpressionFromArray(array),
+    property: identifier(property)
+  });
+}
 export function getTokenProperty(propertyName, tokenName, tokenFallback) {
+  var isFallbackMember = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
   return property({
     key: identifier(propertyName),
-    value: getTokenNode(tokenName, tokenFallback)
+    value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
   });
 }
 export function getLiteralProperty(propertyName, propertyValue) {
@@ -126,4 +144,19 @@ export function convertPropertyNodeToStringableNode(node) {
     key: node.key,
     value: node.value
   });
+}
+export function insertTokensImport(root, fixer) {
+  return Root.insertImport(root, {
+    module: '@atlaskit/tokens',
+    specifiers: ['token']
+  }, fixer);
+}
+export function insertFallbackImportFull(root, fixer) {
+  return Root.insertImport(root, {
+    module: '@atlaskit/theme/typography',
+    specifiers: ['fontFallback']
+  }, fixer);
+}
+export function insertFallbackImportSpecifier(fixer, themeImportNode) {
+  return Import.insertNamedSpecifiers(themeImportNode, ['fontFallback'], fixer);
 }

package/dist/types/rules/prefer-primitives/index.d.ts

@@ -1,3 +1,2 @@
-import type { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
+declare const rule: import("eslint").Rule.RuleModule;
 export default rule;

package/dist/types/rules/use-tokens-typography/transformers/style-object.d.ts

@@ -8,6 +8,8 @@ interface Refs {
     fontSizeNode: Property;
     fontSizeRaw: string | number;
     tokensImportNode: ImportDeclaration | undefined;
+    themeImportNode: ImportDeclaration | undefined;
+    shouldAddFallbackImport: 'full' | 'specifier' | false;
 }
 type Check = {
     success: boolean;
@@ -17,6 +19,8 @@ interface FixerRefs {
     matchingToken: TokenValueMap;
     nodesToReplace: Property[];
     tokensImportNode: ImportDeclaration | undefined;
+    themeImportNode: ImportDeclaration | undefined;
+    shouldAddFallbackImport: Refs['shouldAddFallbackImport'];
     fontWeightReplacement: StringableASTNode<Property> | undefined;
     fontFamilyReplacement: StringableASTNode<Property> | undefined;
     fontStyleReplacement: StringableASTNode<Property> | undefined;

package/dist/types/rules/use-tokens-typography/utils.d.ts

@@ -1,4 +1,5 @@
-import { CallExpression, EslintNode, Property } from 'eslint-codemod-utils';
+import type { Rule } from 'eslint';
+import { CallExpression, Directive, EslintNode, ImportDeclaration, ModuleDeclaration, Property, Statement, StringableASTNode } from 'eslint-codemod-utils';
 export declare const typographyProperties: string[];
 export declare const isTypographyProperty: (propertyName: string) => boolean;
 export declare const isFontSize: (node: EslintNode) => node is CallExpression;
@@ -189,6 +190,9 @@ export declare const fontFamilyTokens: ({
 export declare function findFontFamilyValueForToken(tokenName: string): string;
 export declare function notUndefined<V>(value: V | undefined): value is V;
 export declare function isValidPropertyNode(node: Property): boolean;
-export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback: string): import("eslint-codemod-utils").StringableASTNode<Property>;
-export declare function getLiteralProperty(propertyName: string, propertyValue: string): import("eslint-codemod-utils").StringableASTNode<Property>;
-export declare function convertPropertyNodeToStringableNode(node: Property): import("eslint-codemod-utils").StringableASTNode<Property>;
+export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback: string, isFallbackMember?: boolean): StringableASTNode<Property>;
+export declare function getLiteralProperty(propertyName: string, propertyValue: string): StringableASTNode<Property>;
+export declare function convertPropertyNodeToStringableNode(node: Property): StringableASTNode<Property>;
+export declare function insertTokensImport(root: (Directive | Statement | ModuleDeclaration)[], fixer: Rule.RuleFixer): Rule.Fix;
+export declare function insertFallbackImportFull(root: (Directive | Statement | ModuleDeclaration)[], fixer: Rule.RuleFixer): Rule.Fix;
+export declare function insertFallbackImportSpecifier(fixer: Rule.RuleFixer, themeImportNode: ImportDeclaration): Rule.Fix | undefined;

package/dist/types-ts4.5/rules/prefer-primitives/index.d.ts

@@ -1,3 +1,2 @@
-import type { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
+declare const rule: import("eslint").Rule.RuleModule;
 export default rule;

package/dist/types-ts4.5/rules/use-tokens-typography/transformers/style-object.d.ts

@@ -8,6 +8,8 @@ interface Refs {
     fontSizeNode: Property;
     fontSizeRaw: string | number;
     tokensImportNode: ImportDeclaration | undefined;
+    themeImportNode: ImportDeclaration | undefined;
+    shouldAddFallbackImport: 'full' | 'specifier' | false;
 }
 type Check = {
     success: boolean;
@@ -17,6 +19,8 @@ interface FixerRefs {
     matchingToken: TokenValueMap;
     nodesToReplace: Property[];
     tokensImportNode: ImportDeclaration | undefined;
+    themeImportNode: ImportDeclaration | undefined;
+    shouldAddFallbackImport: Refs['shouldAddFallbackImport'];
     fontWeightReplacement: StringableASTNode<Property> | undefined;
     fontFamilyReplacement: StringableASTNode<Property> | undefined;
     fontStyleReplacement: StringableASTNode<Property> | undefined;

package/dist/types-ts4.5/rules/use-tokens-typography/utils.d.ts

@@ -1,4 +1,5 @@
-import { CallExpression, EslintNode, Property } from 'eslint-codemod-utils';
+import type { Rule } from 'eslint';
+import { CallExpression, Directive, EslintNode, ImportDeclaration, ModuleDeclaration, Property, Statement, StringableASTNode } from 'eslint-codemod-utils';
 export declare const typographyProperties: string[];
 export declare const isTypographyProperty: (propertyName: string) => boolean;
 export declare const isFontSize: (node: EslintNode) => node is CallExpression;
@@ -189,6 +190,9 @@ export declare const fontFamilyTokens: ({
 export declare function findFontFamilyValueForToken(tokenName: string): string;
 export declare function notUndefined<V>(value: V | undefined): value is V;
 export declare function isValidPropertyNode(node: Property): boolean;
-export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback: string): import("eslint-codemod-utils").StringableASTNode<Property>;
-export declare function getLiteralProperty(propertyName: string, propertyValue: string): import("eslint-codemod-utils").StringableASTNode<Property>;
-export declare function convertPropertyNodeToStringableNode(node: Property): import("eslint-codemod-utils").StringableASTNode<Property>;
+export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback: string, isFallbackMember?: boolean): StringableASTNode<Property>;
+export declare function getLiteralProperty(propertyName: string, propertyValue: string): StringableASTNode<Property>;
+export declare function convertPropertyNodeToStringableNode(node: Property): StringableASTNode<Property>;
+export declare function insertTokensImport(root: (Directive | Statement | ModuleDeclaration)[], fixer: Rule.RuleFixer): Rule.Fix;
+export declare function insertFallbackImportFull(root: (Directive | Statement | ModuleDeclaration)[], fixer: Rule.RuleFixer): Rule.Fix;
+export declare function insertFallbackImportSpecifier(fixer: Rule.RuleFixer, themeImportNode: ImportDeclaration): Rule.Fix | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaskit/eslint-plugin-design-system",
   "description": "The essential plugin for use with the Atlassian Design System.",
-  "version": "9.0.0",
+  "version": "9.2.0",
   "author": "Atlassian Pty Ltd",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -48,7 +48,7 @@
   },
   "devDependencies": {
     "@atlaskit/ds-lib": "^2.2.0",
-    "@atlaskit/theme": "^12.6.0",
+    "@atlaskit/theme": "^12.7.0",
     "@atlassian/atlassian-frontend-prettier-config-1.0.1": "npm:@atlassian/atlassian-frontend-prettier-config@1.0.1",
     "@atlassian/codegen": "*",
     "@atlassian/eslint-utils": "^0.4.0",