@atlaskit/eslint-plugin-design-system 11.9.0 → 12.0.0

package/dist/esm/rules/no-legacy-icons/helpers.js

@@ -463,10 +463,25 @@ var createImportFix = function createImportFix(_ref6) {
   var importPath = migrationImportNode ? importSource.replace('/migration', '').split('--')[0] : getNewIconNameAndImportPath(importSource, shouldUseMigrationPath).importPath;
   var useMigrationPath = legacyImportNode && importPath;
   var useFinalPath = migrationImportNode && !shouldUseMigrationPath && importPath;
+  var programNode = legacyImportNode && findProgramNode(legacyImportNode);
   if (useMigrationPath) {
-    fixes.push(newIconName ? fixer.insertTextBefore(legacyImportNode, "import ".concat(newIconName, " from '").concat(importPath, "';\n")) : fixer.replaceText(legacyImportNode.source, "'".concat(literal(importPath), "'")));
+    if (newIconName) {
+      var isExisting = programNode ? alreadyHasImportedLocalName(programNode, newIconName, importPath) : false;
+      if (!isExisting) {
+        fixes.push(fixer.insertTextBefore(legacyImportNode, "import ".concat(newIconName, " from '").concat(importPath, "';\n")));
+      }
+    } else {
+      fixes.push(fixer.replaceText(legacyImportNode.source, "'".concat(literal(importPath), "'")));
+    }
   } else if (useFinalPath) {
-    fixes.push(newIconName ? fixer.insertTextBefore(migrationImportNode, "import ".concat(newIconName, " from '").concat(importPath, "';\n")) : fixer.replaceText(migrationImportNode.source, "'".concat(literal(importPath), "'")));
+    if (newIconName) {
+      var _isExisting = programNode ? alreadyHasImportedLocalName(programNode, newIconName, importPath) : false;
+      if (!_isExisting) {
+        fixes.push(fixer.insertTextBefore(migrationImportNode, "import ".concat(newIconName, " from '").concat(importPath, "';\n")));
+      }
+    } else {
+      fixes.push(fixer.replaceText(migrationImportNode.source, "'".concat(literal(importPath), "'")));
+    }
   }
   return fixes;
 };
@@ -769,4 +784,26 @@ export var throwAutoErrors = function throwAutoErrors(_ref10) {
   for (var _i3 = 0, _Object$entries3 = Object.entries(groupedErrorList); _i3 < _Object$entries3.length; _i3++) {
     _loop();
   }
-};
+};
+function findProgramNode(node) {
+  while (node && node.parent) {
+    if (node.parent.type === 'Program') {
+      return node.parent;
+    }
+    node = node.parent;
+  }
+  return null;
+}
+function alreadyHasImportedLocalName(programNode, localName, importPath) {
+  if (!(programNode !== null && programNode !== void 0 && programNode.body)) {
+    return false;
+  }
+  return programNode.body.some(function (stmt) {
+    if (stmt.type === 'ImportDeclaration' && stmt.source.value === importPath) {
+      return stmt.specifiers.some(function (s) {
+        return s.local.name === localName;
+      });
+    }
+    return false;
+  });
+}

package/dist/esm/rules/no-margin/index.js

@@ -20,16 +20,16 @@ var rule = createLintRule({
       // CSSObjectExpression and StyledObjectExpression
       // const cssObjectExpression = css({ margin: '4px' })
       // const styledObjectExpression = styled.div({margin: '8px'})
-      'CallExpression[callee.name=css] > ObjectExpression, CallExpression[callee.object.name=styled] > ObjectExpression': function CallExpressionCalleeNameCssObjectExpressionCallExpressionCalleeObjectNameStyledObjectExpression(parentNode) {
+      'CallExpression[callee.name=css] > ObjectExpression, CallExpression[callee.object.name=styled] > ObjectExpression': function CallExpressionCalleeNameCss__ObjectExpression_CallExpressionCalleeObjectNameStyled__ObjectExpression(parentNode) {
         if (!isNodeOfType(parentNode, 'ObjectExpression')) {
           return;
         }
-        var findObjectStyles = function findObjectStyles(node) {
+        var _findObjectStyles = function findObjectStyles(node) {
           if (!isNodeOfType(node, 'Property')) {
             return;
           }
           if (isNodeOfType(node.value, 'ObjectExpression')) {
-            return node.value.properties.forEach(findObjectStyles);
+            return node.value.properties.forEach(_findObjectStyles);
           }
           if (!isNodeOfType(node.key, 'Identifier')) {
             return;
@@ -42,7 +42,7 @@ var rule = createLintRule({
           }
           return;
         };
-        parentNode.properties.forEach(findObjectStyles);
+        parentNode.properties.forEach(_findObjectStyles);
       },
       // CSSTemplateLiteral and StyledTemplateLiteral
       // const cssTemplateLiteral = css`color: red; margin: 12px`;

package/dist/esm/rules/no-nested-styles/index.js

@@ -1,7 +1,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { getScope } from '../utils/context-compat';
+import { getScope } from '@atlaskit/eslint-utils/context-compat';
 import { createLintRule } from '../utils/create-rule';
 import { findIdentifierInParentScope } from '../utils/find-in-parent';
 var allowedPrefix = [':', '&:'];
@@ -104,7 +104,7 @@ var rule = createLintRule({
   },
   create: function create(context) {
     return {
-      'CallExpression[callee.name=css] > ObjectExpression Property,CallExpression[callee.name=xcss] > ObjectExpression Property': function CallExpressionCalleeNameCssObjectExpressionPropertyCallExpressionCalleeNameXcssObjectExpressionProperty(node) {
+      'CallExpression[callee.name=css] > ObjectExpression Property,CallExpression[callee.name=xcss] > ObjectExpression Property': function CallExpressionCalleeNameCss__ObjectExpression_PropertyCallExpressionCalleeNameXcss__ObjectExpression_Property(node) {
         if (node.type !== 'Property' || node.value.type !== 'ObjectExpression') {
           return;
         }

package/dist/esm/rules/no-physical-properties/index.js

@@ -19,7 +19,7 @@ var rule = createLintRule({
   },
   create: function create(context) {
     return {
-      'CallExpression[callee.name=css] > ObjectExpression Property,CallExpression[callee.name=xcss] > ObjectExpression Property': function CallExpressionCalleeNameCssObjectExpressionPropertyCallExpressionCalleeNameXcssObjectExpressionProperty(node) {
+      'CallExpression[callee.name=css] > ObjectExpression Property,CallExpression[callee.name=xcss] > ObjectExpression Property': function CallExpressionCalleeNameCss__ObjectExpression_PropertyCallExpressionCalleeNameXcss__ObjectExpression_Property(node) {
         if (!isNodeOfType(node, 'Property')) {
           return;
         }

package/dist/esm/rules/no-unsafe-design-token-usage/index.js

@@ -74,7 +74,7 @@ var rule = createLintRule({
           return;
         }
       },
-      'ObjectExpression > Property > Literal': function ObjectExpressionPropertyLiteral(node) {
+      'ObjectExpression > Property > Literal': function ObjectExpression__Property__Literal(node) {
         if (node.type !== 'Literal') {
           return;
         }
@@ -100,7 +100,7 @@ var rule = createLintRule({
           return;
         }
       },
-      'CallExpression:matches([callee.name="token"], [callee.name="getTokenValue"])': function CallExpressionMatchesCalleeNameTokenCalleeNameGetTokenValue(node) {
+      'CallExpression:matches([callee.name="token"], [callee.name="getTokenValue"])': function CallExpressionMatchesCalleeNameToken_CalleeNameGetTokenValue(node) {
         if (!isNodeOfType(node, 'CallExpression')) {
           return;
         }

package/dist/esm/rules/no-unsafe-style-overrides/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { getSourceCode } from '../utils/context-compat';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { createLintRule } from '../utils/create-rule';
 import { getModuleOfIdentifier } from '../utils/get-import-node-by-source';
 import { getJSXElementName } from '../utils/jsx';

package/dist/esm/rules/use-heading/config/index.js

@@ -2,7 +2,7 @@ var defaults = {
   failSilently: false,
   patterns: ['native-elements'],
   enableUnsafeAutofix: false,
-  enableUnsafeReport: false
+  enableUnsafeReport: true
 };
 export var getConfig = function getConfig(overrides) {
   return Object.assign({}, defaults, overrides);

package/dist/esm/rules/use-heading/index.js

@@ -9,6 +9,18 @@ var rule = createLintRule({
     type: 'suggestion',
     fixable: 'code',
     hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      properties: {
+        enableUnsafeReport: {
+          type: 'boolean'
+        },
+        enableUnsafeAutofix: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }],
     docs: {
       description: 'Encourage the usage of heading components.',
       recommended: false,
@@ -22,7 +34,7 @@ var rule = createLintRule({
     var config = getConfig(context.options[0]);
     return errorBoundary({
       // transforms <h1>...</h1> usages
-      'JSXElement[openingElement.name.name=/^h[0-6]$/]': function JSXElementOpeningElementNameNameH06$(node) {
+      'JSXElement[openingElement.name.name=/^h[0-6]$/]': function JSXElementOpeningElementNameName_H06$_(node) {
         return NativeElements.lint(node, {
           context: context,
           config: config

package/dist/esm/rules/use-heading-level-in-spotlight-card/index.js

@@ -1,7 +1,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { getScope } from '../utils/context-compat';
+import { getScope } from '@atlaskit/eslint-utils/context-compat';
 import { createLintRule } from '../utils/create-rule';
 import { getImportName } from '../utils/get-import-name';
 export var headingLevelRequiredSuggestionText = 'Add a `headingLevel` that is of a contextually relevant level.';

package/dist/esm/rules/use-href-in-link-item/index.js

@@ -1,7 +1,7 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { getScope } from '../utils/context-compat';
+import { getScope } from '@atlaskit/eslint-utils/context-compat';
 import { createLintRule } from '../utils/create-rule';
 import { getImportName } from '../utils/get-import-name';
 import { getUniqueButtonItemName, hasImportOfName, hrefHasInvalidValue, insertButtonItemDefaultImport, insertButtonItemImport } from './utils';

package/dist/esm/rules/use-latest-xcss-syntax/index.js

@@ -18,7 +18,7 @@ var rule = createLintRule({
   },
   create: function create(context) {
     return {
-      'CallExpression[callee.name="xcss"] ObjectExpression Property': function CallExpressionCalleeNameXcssObjectExpressionProperty(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression Property': function CallExpressionCalleeNameXcss_ObjectExpression_Property(node) {
         return StyleProperty.lint(node, {
           context: context
         });

package/dist/esm/rules/use-latest-xcss-syntax/transformers/style-property/index.js

@@ -1,8 +1,8 @@
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../../ast-nodes';
-import { getSourceCode } from '../../../utils/context-compat';
 import { styleMap } from './style-map';
 import supported from './supported';
 var messageId = 'noRawSpacingValues';

package/dist/esm/rules/use-latest-xcss-syntax-typography/config/index.js

@@ -1,6 +1,7 @@
+export var PATTERNS = ['restricted-property', 'wrapped-token-value', 'restricted-capitalisation'];
 var defaults = {
   failSilently: false,
-  patterns: ['restricted-property', 'wrapped-token-value', 'restricted-capitalisation']
+  patterns: [].concat(PATTERNS)
 };
 export var getConfig = function getConfig(overrides) {
   return Object.assign({}, defaults, overrides);

package/dist/esm/rules/use-latest-xcss-syntax-typography/index.js

@@ -1,6 +1,6 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
-import { getConfig } from './config';
+import { getConfig, PATTERNS } from './config';
 import { RestrictedCapitalisation, RestrictedProperty, WrappedTokenValue } from './linters';
 var typescriptErrorMessage = 'There is ongoing work to make this a TypeScript error. Once that happens, you will have to delete/refactor anyway.';
 var rule = createLintRule({
@@ -9,6 +9,24 @@ var rule = createLintRule({
     type: 'problem',
     fixable: 'code',
     hasSuggestions: false,
+    schema: [{
+      type: 'object',
+      properties: {
+        failSilently: {
+          type: 'boolean'
+        },
+        patterns: {
+          maxLength: PATTERNS.length,
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: PATTERNS
+          },
+          uniqueItems: true
+        }
+      },
+      additionalProperties: false
+    }],
     docs: {
       description: 'Prohibits use of unsafe styling properties in xcss. Please use Text/Heading primitives instead.',
       recommended: true,
@@ -24,37 +42,37 @@ var rule = createLintRule({
   create: function create(context) {
     var config = getConfig(context.options[0]);
     return errorBoundary({
-      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=/(fontSize|lineHeight|fontWeight|letterSpacing)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyIdentifierNameFontSizeLineHeightFontWeightLetterSpacing(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=/(fontSize|lineHeight|fontWeight|letterSpacing)/]': function CallExpressionCalleeNameXcss_ObjectExpression__Property__IdentifierName_FontSizeLineHeightFontWeightLetterSpacing_(node) {
         return RestrictedProperty.lint(node, {
           context: context,
           config: config
         });
       },
-      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=/(fontSize|lineHeight|fontWeight|letterSpacing)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyLiteralValueFontSizeLineHeightFontWeightLetterSpacing(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=/(fontSize|lineHeight|fontWeight|letterSpacing)/]': function CallExpressionCalleeNameXcss_ObjectExpression__Property__LiteralValue_FontSizeLineHeightFontWeightLetterSpacing_(node) {
         return RestrictedProperty.lint(node, {
           context: context,
           config: config
         });
       },
-      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=textTransform]': function CallExpressionCalleeNameXcssObjectExpressionPropertyIdentifierNameTextTransform(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=textTransform]': function CallExpressionCalleeNameXcss_ObjectExpression__Property__IdentifierNameTextTransform(node) {
         return RestrictedCapitalisation.lint(node, {
           context: context,
           config: config
         });
       },
-      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=textTransform]': function CallExpressionCalleeNameXcssObjectExpressionPropertyLiteralValueTextTransform(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=textTransform]': function CallExpressionCalleeNameXcss_ObjectExpression__Property__LiteralValueTextTransform(node) {
         return RestrictedCapitalisation.lint(node, {
           context: context,
           config: config
         });
       },
-      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=/(font|fontFamily|fontWeight)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyIdentifierNameFontFontFamilyFontWeight(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Identifier[name=/(font|fontFamily|fontWeight)/]': function CallExpressionCalleeNameXcss_ObjectExpression__Property__IdentifierName_FontFontFamilyFontWeight_(node) {
         return WrappedTokenValue.lint(node, {
           context: context,
           config: config
         });
       },
-      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=/(font|fontFamily|fontWeight)/]': function CallExpressionCalleeNameXcssObjectExpressionPropertyLiteralValueFontFontFamilyFontWeight(node) {
+      'CallExpression[callee.name="xcss"] ObjectExpression > Property > Literal[value=/(font|fontFamily|fontWeight)/]': function CallExpressionCalleeNameXcss_ObjectExpression__Property__LiteralValue_FontFontFamilyFontWeight_(node) {
         return WrappedTokenValue.lint(node, {
           context: context,
           config: config

package/dist/esm/rules/use-primitives/config/index.js

@@ -1,3 +1,43 @@
+export var VALID_PATTERNS = [
+// this enables the rule to look for a pattern like:
+// const myStyles = css({...})
+'compiled-css-function',
+// this enables the rule to look for a pattern like:
+// const MyComponent = styled.div({...})
+'compiled-styled-object',
+// this enables the rule to look for a pattern like:
+// css({ padding: `I AM A TEMPLATE LITERAL` })
+// or styled.div({ padding: `I AM A TEMPLATE LITERAL` })
+'css-template-literal',
+// this enables the rule to look for a pattern like:
+// css({ padding: token(...) })
+// or styled.div({ padding: token(...) })
+'css-property-with-tokens',
+// this enables the rule to look for a pattern like:
+// css({ padding: '8px 16px' })
+// or styled.div({ padding: css({ padding: '8px 16px' }) })
+// ... and they could be tokenised
+// ... and they could be using template literals
+'css-property-multiple-values',
+// This enables the rule to look for a pattern like:
+// ```
+// const styles = css({ // or `styled.div({`
+//   padding: '8px',
+//   margin: '8px',
+// })
+'multiple-properties',
+// This enables the rule to look for supported dimension properties set as 100% like:
+// ```
+// const styles = css({ // or `styled.div({`
+//   padding: '8px',
+//   margin: '8px',
+//   width: '100%',
+// })
+'dimension-properties',
+// This enables the rule to look for JSX elements that are defined before the styles
+'jsx-order-fix',
+// This enables a fix for string style properties being incorrectly transformed
+'string-style-property-fix'];
 var defaults = {
   patterns: ['compiled-css-function']
 };

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

@@ -1,5 +1,5 @@
 import { createLintRule } from '../utils/create-rule';
-import { getConfig } from './config';
+import { getConfig, VALID_PATTERNS } from './config';
 import { CompiledStyled, EmotionCSS } from './transformers';
 var boxDocsUrl = 'https://atlassian.design/components/primitives/box';
 var rule = createLintRule({
@@ -13,6 +13,20 @@ var rule = createLintRule({
       recommended: false,
       severity: 'warn'
     },
+    schema: [{
+      type: 'object',
+      properties: {
+        patterns: {
+          type: 'array',
+          maxLength: VALID_PATTERNS.length,
+          items: {
+            type: 'string',
+            enum: VALID_PATTERNS
+          }
+        }
+      },
+      additionalProperties: false
+    }],
     messages: {
       preferPrimitivesBox: "This element can be replaced with a \"Box\" primitive. See ".concat(boxDocsUrl, " for additional guidance.")
     }

package/dist/esm/rules/use-primitives/transformers/compiled-styled/index.js

@@ -2,8 +2,8 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../../ast-nodes';
-import { getScope, getSourceCode } from '../../../utils/context-compat';
 import { isValidCssPropertiesToTransform } from '../../utils';
 import { validateStyles } from '../../utils/validate-styles';
 import { convertJsxCallSite } from './convert-jsx-call-site';

package/dist/esm/rules/use-primitives/transformers/css-to-xcss.js

@@ -3,8 +3,8 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 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 { getIdentifierInParentScope, identifier, isNodeOfType, literal } from 'eslint-codemod-utils';
+import { getScope } from '@atlaskit/eslint-utils/context-compat';
 import { allSpaceMap, positiveSpaceMap } from '../../../common/token-maps.partial';
-import { getScope } from '../../utils/context-compat';
 import { getAttributeValueIdentifier, getFunctionArgumentAtPos, getJSXAttributeByName, getVariableDefinitionValue } from '../utils';
 export var cssToXcssTransformer = function cssToXcssTransformer(node, context, fixer) {
   /**

package/dist/esm/rules/use-primitives/transformers/emotion-css/index.js

@@ -2,8 +2,8 @@ import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { getIdentifierInParentScope, isNodeOfType } from 'eslint-codemod-utils';
+import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../../ast-nodes';
-import { getScope, getSourceCode } from '../../../utils/context-compat';
 import { getVariableDefinitionValue, getVariableUsagesCount, isValidCssPropertiesToTransform } from '../../utils';
 import { validateStyles } from '../../utils/validate-styles';
 import { cssToXcssTransformer } from '../css-to-xcss';

package/dist/esm/rules/use-primitives/utils/get-variable-usage-count.js

@@ -1,4 +1,4 @@
-import { getSourceCode } from '../../utils/context-compat';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 
 /**
  * TODO: Update this logic: https://product-fabric.atlassian.net/browse/DSP-16059

package/dist/esm/rules/use-primitives-text/config/index.js

@@ -1,9 +1,18 @@
+export var PATTERNS = [
+// <p>text</p>
+'paragraph-elements',
+// <span>text</span>
+'span-elements',
+// <strong>text</strong>
+'strong-elements',
+// <em>text</em>
+'emphasis-elements'];
 var defaults = {
   failSilently: false,
   patterns: ['paragraph-elements', 'span-elements', 'strong-elements', 'emphasis-elements'],
   inheritColor: false,
   enableUnsafeAutofix: false,
-  enableUnsafeReport: false
+  enableUnsafeReport: true
 };
 export var getConfig = function getConfig(overrides) {
   return Object.assign({}, defaults, overrides);

package/dist/esm/rules/use-primitives-text/index.js

@@ -1,6 +1,6 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
-import { getConfig } from './config';
+import { getConfig, PATTERNS } from './config';
 import { EmphasisElements, ParagraphElements, SpanElements, StrongElements } from './transformers';
 var textDocsUrl = 'https://atlassian.design/components/primitives/text';
 var rule = createLintRule({
@@ -9,6 +9,33 @@ var rule = createLintRule({
     type: 'suggestion',
     fixable: 'code',
     hasSuggestions: true,
+    schema: [{
+      type: 'object',
+      properties: {
+        failSilently: {
+          type: 'boolean'
+        },
+        inheritColor: {
+          type: 'boolean'
+        },
+        enableUnsafeAutofix: {
+          type: 'boolean'
+        },
+        enableUnsafeReport: {
+          type: 'boolean'
+        },
+        patterns: {
+          maxLength: PATTERNS.length,
+          type: 'array',
+          items: {
+            type: 'string',
+            enum: PATTERNS
+          },
+          uniqueItems: true
+        }
+      },
+      additionalProperties: false
+    }],
     docs: {
       description: 'Encourage the usage of text components.',
       recommended: false,

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

@@ -5,8 +5,8 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../ast-nodes';
-import { getSourceCode } from '../../utils/context-compat';
 import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export var EmphasisElements = {
   lint: function lint(node, _ref) {

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

@@ -5,8 +5,8 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../ast-nodes';
-import { getSourceCode } from '../../utils/context-compat';
 import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export var ParagraphElements = {
   lint: function lint(node, _ref) {

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

@@ -5,8 +5,8 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../ast-nodes';
-import { getSourceCode } from '../../utils/context-compat';
 import { addColorInheritAttributeFix, allowedAttrs, hasTextChildrenOnly, updateTestIdAttributeFix } from './common';
 export var SpanElements = {
   lint: function lint(node, _ref) {

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

@@ -5,8 +5,8 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import * as ast from '../../../ast-nodes';
-import { getSourceCode } from '../../utils/context-compat';
 import { addColorInheritAttributeFix, allowedAttrs, updateTestIdAttributeFix } from './common';
 export var StrongElements = {
   lint: function lint(node, _ref) {

package/dist/esm/rules/use-tokens-space/index.js

@@ -17,27 +17,27 @@ var rule = createLintRule({
   },
   create: function create(context) {
     return {
-      'CallExpression[callee.name="css"] ObjectExpression Property': function CallExpressionCalleeNameCssObjectExpressionProperty(node) {
+      'CallExpression[callee.name="css"] ObjectExpression Property': function CallExpressionCalleeNameCss_ObjectExpression_Property(node) {
         return StyleProperty.lint(node, {
           context: context
         });
       },
-      'CallExpression[callee.name="keyframes"] ObjectExpression Property': function CallExpressionCalleeNameKeyframesObjectExpressionProperty(node) {
+      'CallExpression[callee.name="keyframes"] ObjectExpression Property': function CallExpressionCalleeNameKeyframes_ObjectExpression_Property(node) {
         return StyleProperty.lint(node, {
           context: context
         });
       },
-      'CallExpression[callee.name="cssMap"] ObjectExpression Property': function CallExpressionCalleeNameCssMapObjectExpressionProperty(node) {
+      'CallExpression[callee.name="cssMap"] ObjectExpression Property': function CallExpressionCalleeNameCssMap_ObjectExpression_Property(node) {
         return StyleProperty.lint(node, {
           context: context
         });
       },
-      'CallExpression[callee.object.name=styled] ObjectExpression Property': function CallExpressionCalleeObjectNameStyledObjectExpressionProperty(node) {
+      'CallExpression[callee.object.name=styled] ObjectExpression Property': function CallExpressionCalleeObjectNameStyled_ObjectExpression_Property(node) {
         return StyleProperty.lint(node, {
           context: context
         });
       },
-      'CallExpression[callee.object.name=styled2] ObjectExpression Property': function CallExpressionCalleeObjectNameStyled2ObjectExpressionProperty(node) {
+      'CallExpression[callee.object.name=styled2] ObjectExpression Property': function CallExpressionCalleeObjectNameStyled2_ObjectExpression_Property(node) {
         return StyleProperty.lint(node, {
           context: context
         });

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

@@ -28,7 +28,7 @@ var defaultConfig = {
   failSilently: false,
   shouldEnforceFallbacks: false,
   enableUnsafeAutofix: false,
-  patterns: ['style-object']
+  patterns: ['style-object', 'font-weight', 'font-family', 'untokenized-properties', 'banned-properties', 'restricted-capitalisation']
 };
 export var getConfig = function getConfig(overrides) {
   return Object.assign({}, defaultConfig, overrides);

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

@@ -18,35 +18,35 @@ var create = function create(context) {
       });
     },
     // const styles = css({ fontWeight: 600, 'bold', ... })
-    'ObjectExpression > Property > Identifier[name=/^fontWeight$/]': function ObjectExpressionPropertyIdentifierNameFontWeight$(node) {
+    'ObjectExpression > Property > Identifier[name=/^fontWeight$/]': function ObjectExpression__Property__IdentifierName_FontWeight$_(node) {
       return FontWeight.lint(node.parent, {
         context: context,
         config: config
       });
     },
     // const styles = css({ fontFamily: 'Arial, sans-serif', ... })
-    'ObjectExpression > Property > Identifier[name=/^fontFamily$/]': function ObjectExpressionPropertyIdentifierNameFontFamily$(node) {
+    'ObjectExpression > Property > Identifier[name=/^fontFamily$/]': function ObjectExpression__Property__IdentifierName_FontFamily$_(node) {
       return FontFamily.lint(node.parent, {
         context: context,
         config: config
       });
     },
     // const styles = css({ font: 'bold 36px Helvetica, Arial', ... })
-    'ObjectExpression > Property > Identifier[name=/^font$/]': function ObjectExpressionPropertyIdentifierNameFont$(node) {
+    'ObjectExpression > Property > Identifier[name=/^font$/]': function ObjectExpression__Property__IdentifierName_Font$_(node) {
       return UntokenizedProperties.lint(node.parent, {
         context: context,
         config: config
       });
     },
     // const styles = css({ lineHeight: 1.2, letterSpacing: 0.003, ... })
-    'ObjectExpression > Property > Identifier[name=/^(lineHeight|letterSpacing)$/]': function ObjectExpressionPropertyIdentifierNameLineHeightLetterSpacing$(node) {
+    'ObjectExpression > Property > Identifier[name=/^(lineHeight|letterSpacing)$/]': function ObjectExpression__Property__IdentifierName_LineHeightLetterSpacing$_(node) {
       return BannedProperties.lint(node.parent, {
         context: context,
         config: config
       });
     },
     // const styles = css({ textTransform: 'uppercase', ... })
-    'ObjectExpression > Property > Identifier[name=/^textTransform$/]': function ObjectExpressionPropertyIdentifierNameTextTransform$(node) {
+    'ObjectExpression > Property > Identifier[name=/^textTransform$/]': function ObjectExpression__Property__IdentifierName_TextTransform$_(node) {
       return RestrictedCapitalisation.lint(node.parent, {
         context: context,
         config: config
@@ -66,7 +66,8 @@ var rule = createLintRule({
       severity: 'warn'
     },
     messages: {
-      noRawTypographyValues: 'Typography primitives or tokens should be used instead of hard-coded values.\n\n@meta <<{{payload}}>>.\n\nNOTE: Using tokens with the `fontSize` property is invalid. Any `font.heading` or `font.body` tokens must use the CSS `font` property.',
+      noRawTypographyValues: 'Typography primitives or tokens should be used instead of hard-coded values.',
+      noFontSizeTypographyToken: 'Using tokens with the `fontSize` property is invalid. Any `font.heading` or `font.body` tokens must use the CSS `font` property.',
       noRawFontWeightValues: 'Font weight tokens should be used instead of hard-coded values.',
       noRawFontFamilyValues: 'Font family tokens should be used instead of hard-coded values.',
       noUntokenizedProperties: 'Use typography tokens for `{{property}}`.',