@atlaskit/eslint-plugin-design-system 11.1.0 → 11.3.0

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

@@ -20,7 +20,8 @@ export const ruleSchema = {
 const defaultConfig = {
   failSilently: false,
   shouldEnforceFallbacks: false,
-  enableUnsafeAutofix: false
+  enableUnsafeAutofix: false,
+  patterns: ['style-object']
 };
 export const getConfig = overrides => {
   return Object.assign({}, defaultConfig, overrides);

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

@@ -1,16 +1,22 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig, ruleSchema } from './config';
+import { FontWeight } from './transformers/font-weight';
 import { StyleObject } from './transformers/style-object';
 const create = context => {
   const config = getConfig(context.options[0]);
-  return {
-    // const styles = css({ fontSize: '14px, ... }), styled.div({ fontSize: 14, ... })
-    ObjectExpression: errorBoundary(node => StyleObject.lint(node, {
+  return errorBoundary({
+    // const styles = css({ fontSize: '14px', ... }), styled.div({ fontSize: 14, ... })
+    ObjectExpression: node => StyleObject.lint(node, {
       context,
       config
-    }), config)
-  };
+    }),
+    // const styles = css({ fontWeight: 600, 'bold', ... })
+    'ObjectExpression > Property > Identifier[name=/fontWeight/]': node => FontWeight.lint(node, {
+      context,
+      config
+    })
+  }, config);
 };
 const rule = createLintRule({
   meta: {
@@ -24,7 +30,8 @@ const 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.\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.',
+      noRawFontWeightValues: 'Font weight tokens should be used instead of hard-coded values.'
     },
     schema: ruleSchema
   },

package/dist/es2019/rules/use-tokens-typography/transformers/font-weight.js

@@ -0,0 +1,92 @@
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { Root } from '../../../ast-nodes';
+import { getValueForPropertyNode } from '../../ensure-design-token-usage/utils';
+import { isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
+import { findFontWeightTokenForValue, insertTokensImport } from '../utils';
+export const FontWeight = {
+  lint(node, {
+    context,
+    config
+  }) {
+    // To force the correct node type
+    if (!isNodeOfType(node, 'Identifier')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    const success = FontWeight._check(node, {
+      context,
+      config
+    });
+    if (success) {
+      return context.report({
+        node,
+        messageId: 'noRawFontWeightValues',
+        fix: FontWeight._fix(node, context)
+      });
+    }
+  },
+  _check(node, {
+    context,
+    config
+  }) {
+    if (!config.patterns.includes('font-weight')) {
+      return false;
+    }
+    if (!isDecendantOfStyleBlock(node) && !isDecendantOfType(node, 'JSXExpressionContainer')) {
+      return false;
+    }
+    if (!isNodeOfType(node.parent, 'Property')) {
+      return false;
+    }
+    const fontWeightValue = getValueForPropertyNode(node.parent, context);
+    if (typeof fontWeightValue === 'string' && fontWeightValue.includes('font.weight.')) {
+      return false;
+    }
+    return true;
+  },
+  _fix(node, context) {
+    return fixer => {
+      var _findFontWeightTokenF;
+      const fixes = [];
+
+      // -- Type assertions to force the correct node type --
+
+      if (!isNodeOfType(node.parent, 'Property')) {
+        return [];
+      }
+      if (!isNodeOfType(node.parent.value, 'Literal')) {
+        return [];
+      }
+      if (!node.parent.value.raw) {
+        return [];
+      }
+
+      // -- Fix: Replace raw value with token --
+
+      const matchingToken = (_findFontWeightTokenF = findFontWeightTokenForValue(node.parent.value.raw)) === null || _findFontWeightTokenF === void 0 ? void 0 : _findFontWeightTokenF.tokenName;
+      if (!matchingToken) {
+        return [];
+      }
+      const fontWeightValueFix = fixer.replaceText(node.parent.value, `token('${matchingToken}')`);
+      fixes.push(fontWeightValueFix);
+
+      // -- Fix: Add import if it doesn't exist --
+
+      const body = context.sourceCode.ast.body;
+      const tokensImportDeclarations = Root.findImportsByModule(body, '@atlaskit/tokens');
+
+      // If there is more than one `@atlaskit/tokens` import, then it becomes difficult to determine which import to transform
+      if (tokensImportDeclarations.length > 1) {
+        return fixes;
+      }
+      const tokensImportDeclaration = tokensImportDeclarations[0];
+      if (!tokensImportDeclaration) {
+        fixes.push(insertTokensImport(body, fixer));
+      }
+      return fixes;
+    };
+  }
+};

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

@@ -198,6 +198,11 @@ export const StyleObject = {
     context,
     config
   }) {
+    if (!config.patterns.includes('style-object')) {
+      return {
+        success: false
+      };
+    }
     if (!isDecendantOfStyleBlock(node) && !isDecendantOfType(node, 'JSXExpressionContainer')) {
       return {
         success: false

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

@@ -48,6 +48,12 @@ export const fontWeightTokens = typographyTokens.filter(token => token.attribute
   };
 });
 export function findFontWeightTokenForValue(fontWeight) {
+  if (fontWeight === "'normal'") {
+    fontWeight = '400';
+  }
+  if (fontWeight === "'bold'") {
+    fontWeight = '700';
+  }
   return fontWeightTokens.find(token => token.tokenValue === fontWeight);
 }
 export const fontWeightMap = {

package/dist/esm/rules/no-deprecated-apis/index.js

@@ -1,36 +1,30 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { AST_NODE_TYPES, ASTUtils } from '@typescript-eslint/utils';
-import { createRule } from '../utils/create-rule';
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { createLintRule } from '../utils/create-rule';
 import { getConfig } from '../utils/get-deprecated-config';
 import { isDeprecatedJSXAttributeConfig } from '../utils/types';
 export var noDeprecatedJSXAttributeMessageId = 'noDeprecatedJSXAttributes';
-var isNodeOfType = function isNodeOfType(node, nodeType) {
-  return ASTUtils.isNodeOfType(nodeType)(node);
-};
 var isImportDeclaration = function isImportDeclaration(programStatement) {
   return (programStatement === null || programStatement === void 0 ? void 0 : programStatement.type) === 'ImportDeclaration';
 };
 var findJSXElementName = function findJSXElementName(jsxAttributeNode) {
-  if (!jsxAttributeNode.parent || !isNodeOfType(jsxAttributeNode.parent, AST_NODE_TYPES.JSXOpeningElement)) {
+  if (!jsxAttributeNode.parent || !isNodeOfType(jsxAttributeNode === null || jsxAttributeNode === void 0 ? void 0 : jsxAttributeNode.parent, 'JSXOpeningElement')) {
     return;
   }
   var openingElement = jsxAttributeNode.parent;
-  if (!isNodeOfType(openingElement.name, AST_NODE_TYPES.JSXIdentifier)) {
+  if (!isNodeOfType(openingElement.name, 'JSXIdentifier')) {
     return;
   }
   return openingElement.name.name;
 };
 export var name = 'no-deprecated-apis';
-var rule = createRule({
-  name: name,
-  defaultOptions: [{
-    deprecatedConfig: getConfig('jsxAttributes')
-  }],
+var rule = createLintRule({
   meta: {
+    name: name,
     type: 'suggestion',
     docs: {
       description: 'Disallow using deprecated APIs.',
-      recommended: 'strict'
+      recommended: true,
+      severity: 'error'
     },
     messages: {
       noDeprecatedJSXAttributes: 'The JSX attribute {{propName}} has been deprecated.'
@@ -68,24 +62,18 @@ var rule = createRule({
       }
     }]
   },
-  create: function create(context, _ref) {
+  create: function create(context) {
     var _context$options$;
-    var _ref2 = _slicedToArray(_ref, 1),
-      options = _ref2[0];
-    // Get rule configuration
-    var defaultDeprecatedConfig = options.deprecatedConfig;
-
     // Get the rule configuration specified otherwise use default config.
     // A bit confusing as it seems that the default options have precedence over the user specified options.
-    var deprecatedConfig = ((_context$options$ = context.options[0]) === null || _context$options$ === void 0 ? void 0 : _context$options$.deprecatedConfig) || defaultDeprecatedConfig;
+    var deprecatedConfig = ((_context$options$ = context.options[0]) === null || _context$options$ === void 0 ? void 0 : _context$options$.deprecatedConfig) || getConfig('jsxAttributes');
     return {
       // find JSX atribute - find name of attribute - get source and find relevant identifiers.
       JSXAttribute: function JSXAttribute(node) {
-        var jsxAttributeIdentifier = node.name;
-        if (!isNodeOfType(jsxAttributeIdentifier, AST_NODE_TYPES.JSXIdentifier)) {
+        if (!isNodeOfType(node, 'JSXAttribute') || !isNodeOfType(node.name, 'JSXIdentifier')) {
           return;
         }
-        var jsxAttributeName = jsxAttributeIdentifier.name;
+        var jsxAttributeName = node.name.name;
         if (!isDeprecatedJSXAttributeConfig(deprecatedConfig) || !deprecatedConfig[jsxAttributeName]) {
           return;
         }
@@ -93,13 +81,13 @@ var rule = createRule({
         if (!jsxElementName) {
           return;
         }
-        var source = context.getSourceCode();
+        var source = context.sourceCode;
 
         // find an import for the path of the banned api
         deprecatedConfig[jsxAttributeName].forEach(function (importItem) {
           var _importItem$namedSpec;
           var importNode = source.ast.body.filter(isImportDeclaration).find(function (node) {
-            return node.source.value.includes(importItem.moduleSpecifier);
+            return node && node.source.value && typeof node.source.value === 'string' && node.source.value.includes(importItem.moduleSpecifier);
           });
           if (!importNode) {
             return;

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

@@ -4,7 +4,7 @@ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length)
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { addToListOfRanges, canAutoMigrateNewIconBasedOnSize, canMigrateColor, createAutoMigrationError, createCantFindSuitableReplacementError, createCantMigrateColorError, createCantMigrateFunctionUnknownError, createCantMigrateIdentifierError, createCantMigrateIdentifierMapOrArrayError, createCantMigrateReExportError, createCantMigrateSizeUnknown, createCantMigrateSpreadPropsError, createGuidance, createHelpers, getMigrationMapObject, getUpcomingIcons, isInsideLegacyButton, isInsideNewButton, isSize, locToString, throwAutoErrors, throwManualErrors } from './helpers';
 export var createChecks = function createChecks(context) {
-  //create global variables to be shared by the checks
+  // Create global variables to be shared by the checks
   var _createHelpers = createHelpers(context),
     getPrimaryColor = _createHelpers.getPrimaryColor,
     getConfigFlag = _createHelpers.getConfigFlag;
@@ -21,6 +21,7 @@ export var createChecks = function createChecks(context) {
   var shouldErrorForAutoMigration = getConfigFlag('shouldErrorForAutoMigration', true);
   var isQuietMode = getConfigFlag('quiet', false);
   var shouldUseMigrationPath = getConfigFlag('shouldUseMigrationPath', true);
+  var shouldUseSafeMigrationMode = getConfigFlag('shouldUseSafeMigrationMode', false);
 
   // Sorted list of ranges
   var errorRanges = [];
@@ -405,10 +406,11 @@ export var createChecks = function createChecks(context) {
       // Find size prop on node
       var size = 'medium';
       var primaryColor = null;
+      var hasPrimaryColorProp = false;
+      var hasSecondaryColorProp = false;
       var afterSpreadSet = new Set();
       var requiredAttributesAfterSpread = new Set(['size', 'primaryColor', 'secondaryColor']);
       var hasSpread = false;
-      var hasPrimaryColorProp = false;
       var _iterator8 = _createForOfIteratorHelper(node.openingElement.attributes),
         _step8;
       try {
@@ -443,6 +445,9 @@ export var createChecks = function createChecks(context) {
               primaryColor = getPrimaryColor(attr);
               hasPrimaryColorProp = true;
               break;
+            case 'secondaryColor':
+              hasSecondaryColorProp = true;
+              break;
           }
         }
       } catch (err) {
@@ -451,6 +456,8 @@ export var createChecks = function createChecks(context) {
         _iterator8.f();
       }
       var hasManualMigration = false;
+
+      // Flag manual migration if primary color cannot be migrated
       if (primaryColor && !canMigrateColor(primaryColor) || hasPrimaryColorProp && !primaryColor) {
         createCantMigrateColorError(node, primaryColor ? "the value of '".concat(primaryColor, "'") : 'a statically unknown value', errorsManual, legacyIconImports[name].packageName, name);
         hasManualMigration = true;
@@ -462,6 +469,7 @@ export var createChecks = function createChecks(context) {
         createCantMigrateSizeUnknown(node, errorsManual, legacyIconImports[name].packageName, name);
         hasManualMigration = true;
       }
+
       // Do a set comparison - is requiredAttributesAfterSpread a subset of afterSpreadSet?
       if (hasSpread === true && !Array.from(requiredAttributesAfterSpread).every(function (val) {
         return afterSpreadSet.has(val);
@@ -472,6 +480,7 @@ export var createChecks = function createChecks(context) {
         createCantMigrateSpreadPropsError(node, missingProps, errorsManual, legacyIconImports[name].packageName, name);
         hasManualMigration = true;
       }
+
       // Check if it is an exported component?
       if (legacyIconImports[name].exported) {
         createCantMigrateReExportError(node, legacyIconImports[name].packageName, name, errorsManual);
@@ -501,7 +510,9 @@ export var createChecks = function createChecks(context) {
           spacing = 'spacious';
         }
       }
-      if (!hasManualMigration && (newIcon || upcomingIcon) && isNewIconMigratable) {
+      if (shouldUseSafeMigrationMode && !hasManualMigration && (newIcon !== null && newIcon !== void 0 && newIcon.isMigrationUnsafe || size !== 'medium' || hasSecondaryColorProp)) {
+        createCantFindSuitableReplacementError(node, legacyIconImports[name].packageName, name, errorsManual, upcomingIcon ? true : migrationMapObject ? true : false);
+      } else if (!hasManualMigration && (newIcon || upcomingIcon) && isNewIconMigratable) {
         createAutoMigrationError({
           node: node,
           importSource: legacyIconImports[name].packageName,

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

@@ -470,8 +470,7 @@ var createPropFixes = function createPropFixes(_ref7) {
     migrationImportNode = _ref7.migrationImportNode,
     newIconName = _ref7.newIconName;
   var fixes = [];
-  var spacing = metadata.spacing,
-    insideNewButton = metadata.insideNewButton;
+  var spacing = metadata.spacing;
   if (shouldUseMigrationPath && !legacyImportNode) {
     return fixes;
   }
@@ -488,16 +487,6 @@ var createPropFixes = function createPropFixes(_ref7) {
       fixes.push(fixer.replaceText(primaryColor.name, 'color'));
     }
 
-    // add color="currentColor" if
-    // 1. primaryColor prop is not set
-    // 2. icon is not imported from migration entrypoint
-    // 3. icon element is not inside a new button
-    if (legacyImportNode && !primaryColor && !migrationImportNode &&
-    // value type need to be a string in Rule.ReportDescriptor
-    insideNewButton !== 'true') {
-      fixes.push(fixer.insertTextAfter(openingElement.name, " color=\"currentColor\""));
-    }
-
     // rename or remove size prop based on shouldUseMigrationPath,
     // add spacing="spacious" if
     // 1. it's in error metadata, which means size is medium
@@ -627,12 +616,12 @@ export var throwAutoErrors = function throwAutoErrors(_ref10) {
     }
     return result;
   }, new Set());
-  //group errors by import source and remove any unwanted errors
+  // Group errors by import source and remove any unwanted errors
   var groupedErrorList = Object.entries(errorsAuto).reduce(function (result, option) {
     var _option2 = _slicedToArray(option, 2),
       key = _option2[0],
       error = _option2[1];
-    //return early if no data
+    // Return early if no data
     if (!error.data) {
       return result;
     }

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

@@ -22,6 +22,9 @@ var rule = createLintRule({
         shouldErrorForAutoMigration: {
           type: 'boolean'
         },
+        shouldUseSafeMigrationMode: {
+          type: 'boolean'
+        },
         quiet: {
           type: 'boolean'
         },

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

@@ -20,7 +20,8 @@ export var ruleSchema = {
 var defaultConfig = {
   failSilently: false,
   shouldEnforceFallbacks: false,
-  enableUnsafeAutofix: false
+  enableUnsafeAutofix: false,
+  patterns: ['style-object']
 };
 export var getConfig = function getConfig(overrides) {
   return Object.assign({}, defaultConfig, overrides);

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

@@ -1,18 +1,26 @@
 import { createLintRule } from '../utils/create-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { getConfig, ruleSchema } from './config';
+import { FontWeight } from './transformers/font-weight';
 import { StyleObject } from './transformers/style-object';
 var create = function create(context) {
   var config = getConfig(context.options[0]);
-  return {
-    // const styles = css({ fontSize: '14px, ... }), styled.div({ fontSize: 14, ... })
-    ObjectExpression: errorBoundary(function (node) {
+  return errorBoundary({
+    // const styles = css({ fontSize: '14px', ... }), styled.div({ fontSize: 14, ... })
+    ObjectExpression: function ObjectExpression(node) {
       return StyleObject.lint(node, {
         context: context,
         config: config
       });
-    }, config)
-  };
+    },
+    // const styles = css({ fontWeight: 600, 'bold', ... })
+    'ObjectExpression > Property > Identifier[name=/fontWeight/]': function ObjectExpressionPropertyIdentifierNameFontWeight(node) {
+      return FontWeight.lint(node, {
+        context: context,
+        config: config
+      });
+    }
+  }, config);
 };
 var rule = createLintRule({
   meta: {
@@ -26,7 +34,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.\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.',
+      noRawFontWeightValues: 'Font weight tokens should be used instead of hard-coded values.'
     },
     schema: ruleSchema
   },

package/dist/esm/rules/use-tokens-typography/transformers/font-weight.js

@@ -0,0 +1,90 @@
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { Root } from '../../../ast-nodes';
+import { getValueForPropertyNode } from '../../ensure-design-token-usage/utils';
+import { isDecendantOfStyleBlock, isDecendantOfType } from '../../utils/is-node';
+import { findFontWeightTokenForValue, insertTokensImport } from '../utils';
+export var FontWeight = {
+  lint: function lint(node, _ref) {
+    var context = _ref.context,
+      config = _ref.config;
+    // To force the correct node type
+    if (!isNodeOfType(node, 'Identifier')) {
+      return;
+    }
+
+    // Check whether all criteria needed to make a transformation are met
+    var success = FontWeight._check(node, {
+      context: context,
+      config: config
+    });
+    if (success) {
+      return context.report({
+        node: node,
+        messageId: 'noRawFontWeightValues',
+        fix: FontWeight._fix(node, context)
+      });
+    }
+  },
+  _check: function _check(node, _ref2) {
+    var context = _ref2.context,
+      config = _ref2.config;
+    if (!config.patterns.includes('font-weight')) {
+      return false;
+    }
+    if (!isDecendantOfStyleBlock(node) && !isDecendantOfType(node, 'JSXExpressionContainer')) {
+      return false;
+    }
+    if (!isNodeOfType(node.parent, 'Property')) {
+      return false;
+    }
+    var fontWeightValue = getValueForPropertyNode(node.parent, context);
+    if (typeof fontWeightValue === 'string' && fontWeightValue.includes('font.weight.')) {
+      return false;
+    }
+    return true;
+  },
+  _fix: function _fix(node, context) {
+    return function (fixer) {
+      var _findFontWeightTokenF;
+      var fixes = [];
+
+      // -- Type assertions to force the correct node type --
+
+      if (!isNodeOfType(node.parent, 'Property')) {
+        return [];
+      }
+      if (!isNodeOfType(node.parent.value, 'Literal')) {
+        return [];
+      }
+      if (!node.parent.value.raw) {
+        return [];
+      }
+
+      // -- Fix: Replace raw value with token --
+
+      var matchingToken = (_findFontWeightTokenF = findFontWeightTokenForValue(node.parent.value.raw)) === null || _findFontWeightTokenF === void 0 ? void 0 : _findFontWeightTokenF.tokenName;
+      if (!matchingToken) {
+        return [];
+      }
+      var fontWeightValueFix = fixer.replaceText(node.parent.value, "token('".concat(matchingToken, "')"));
+      fixes.push(fontWeightValueFix);
+
+      // -- Fix: Add import if it doesn't exist --
+
+      var body = context.sourceCode.ast.body;
+      var tokensImportDeclarations = Root.findImportsByModule(body, '@atlaskit/tokens');
+
+      // If there is more than one `@atlaskit/tokens` import, then it becomes difficult to determine which import to transform
+      if (tokensImportDeclarations.length > 1) {
+        return fixes;
+      }
+      var tokensImportDeclaration = tokensImportDeclarations[0];
+      if (!tokensImportDeclaration) {
+        fixes.push(insertTokensImport(body, fixer));
+      }
+      return fixes;
+    };
+  }
+};

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

@@ -199,6 +199,11 @@ export var StyleObject = {
   _check: function _check(node, _ref2) {
     var context = _ref2.context,
       config = _ref2.config;
+    if (!config.patterns.includes('style-object')) {
+      return {
+        success: false
+      };
+    }
     if (!isDecendantOfStyleBlock(node) && !isDecendantOfType(node, 'JSXExpressionContainer')) {
       return {
         success: false

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

@@ -78,6 +78,12 @@ export var fontWeightTokens = typographyTokens.filter(function (token) {
   };
 });
 export function findFontWeightTokenForValue(fontWeight) {
+  if (fontWeight === "'normal'") {
+    fontWeight = '400';
+  }
+  if (fontWeight === "'bold'") {
+    fontWeight = '700';
+  }
   return fontWeightTokens.find(function (token) {
     return token.tokenValue === fontWeight;
   });

package/dist/types/index.codegen.d.ts

@@ -13,9 +13,7 @@ export declare const plugin: {
         'no-css-tagged-template-expression': import("eslint").Rule.RuleModule;
         'no-custom-icons': import("eslint").Rule.RuleModule;
         'no-dark-theme-vr-tests': import("eslint").Rule.RuleModule;
-        'no-deprecated-apis': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<string, [{
-            deprecatedConfig: import("./rules/utils/types").DeprecatedConfig;
-        }], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+        'no-deprecated-apis': import("eslint").Rule.RuleModule;
         'no-deprecated-design-token-usage': import("eslint").Rule.RuleModule;
         'no-deprecated-imports': import("eslint").Rule.RuleModule;
         'no-direct-use-of-web-platform-drag-and-drop': import("eslint").Rule.RuleModule;
@@ -303,9 +301,7 @@ export declare const configs: {
                     'no-css-tagged-template-expression': import("eslint").Rule.RuleModule;
                     'no-custom-icons': import("eslint").Rule.RuleModule;
                     'no-dark-theme-vr-tests': import("eslint").Rule.RuleModule;
-                    'no-deprecated-apis': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<string, [{
-                        deprecatedConfig: import("./rules/utils/types").DeprecatedConfig;
-                    }], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+                    'no-deprecated-apis': import("eslint").Rule.RuleModule;
                     'no-deprecated-design-token-usage': import("eslint").Rule.RuleModule;
                     'no-deprecated-imports': import("eslint").Rule.RuleModule;
                     'no-direct-use-of-web-platform-drag-and-drop': import("eslint").Rule.RuleModule;
@@ -448,9 +444,7 @@ export declare const configs: {
                     'no-css-tagged-template-expression': import("eslint").Rule.RuleModule;
                     'no-custom-icons': import("eslint").Rule.RuleModule;
                     'no-dark-theme-vr-tests': import("eslint").Rule.RuleModule;
-                    'no-deprecated-apis': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<string, [{
-                        deprecatedConfig: import("./rules/utils/types").DeprecatedConfig;
-                    }], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+                    'no-deprecated-apis': import("eslint").Rule.RuleModule;
                     'no-deprecated-design-token-usage': import("eslint").Rule.RuleModule;
                     'no-deprecated-imports': import("eslint").Rule.RuleModule;
                     'no-direct-use-of-web-platform-drag-and-drop': import("eslint").Rule.RuleModule;

package/dist/types/rules/index.codegen.d.ts

@@ -8,9 +8,7 @@ export declare const rules: {
     'no-css-tagged-template-expression': import("eslint").Rule.RuleModule;
     'no-custom-icons': import("eslint").Rule.RuleModule;
     'no-dark-theme-vr-tests': import("eslint").Rule.RuleModule;
-    'no-deprecated-apis': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<string, [{
-        deprecatedConfig: import("./utils/types").DeprecatedConfig;
-    }], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+    'no-deprecated-apis': import("eslint").Rule.RuleModule;
     'no-deprecated-design-token-usage': import("eslint").Rule.RuleModule;
     'no-deprecated-imports': import("eslint").Rule.RuleModule;
     'no-direct-use-of-web-platform-drag-and-drop': import("eslint").Rule.RuleModule;

package/dist/types/rules/no-deprecated-apis/index.d.ts

@@ -1,7 +1,5 @@
-import { type DeprecatedConfig } from '../utils/types';
+import type { Rule } from 'eslint';
 export declare const noDeprecatedJSXAttributeMessageId = "noDeprecatedJSXAttributes";
 export declare const name = "no-deprecated-apis";
-declare const rule: import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<string, [{
-    deprecatedConfig: DeprecatedConfig;
-}], import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+declare const rule: Rule.RuleModule;
 export default rule;

package/dist/types/rules/no-legacy-icons/helpers.d.ts

@@ -48,6 +48,7 @@ export declare const getMigrationMapObject: (iconPackage: string) => {
         name: string;
         type: string;
         package: string;
+        isMigrationUnsafe?: boolean | undefined;
     } | undefined;
     additionalIcons?: {
         name: string;

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

@@ -1,8 +1,11 @@
 import { type JSONSchema4 } from '@typescript-eslint/utils/dist/json-schema';
+type Pattern = 'style-object' | 'font-weight';
 export type RuleConfig = {
     failSilently: boolean;
     shouldEnforceFallbacks: boolean;
     enableUnsafeAutofix: boolean;
+    patterns: Pattern[];
 };
 export declare const ruleSchema: JSONSchema4;
 export declare const getConfig: (overrides: Partial<RuleConfig>) => RuleConfig;
+export {};

package/dist/types/rules/use-tokens-typography/transformers/font-weight.d.ts

@@ -0,0 +1,13 @@
+import type { Rule } from 'eslint';
+import { Identifier } from 'eslint-codemod-utils';
+import { type RuleConfig } from '../config';
+interface MetaData {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+}
+export declare const FontWeight: {
+    lint(node: Rule.Node, { context, config }: MetaData): void;
+    _check(node: Identifier & Rule.NodeParentExtension, { context, config }: MetaData): boolean;
+    _fix(node: Identifier & Rule.NodeParentExtension, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+};
+export {};