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

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

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

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

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

package/dist/types/ast-nodes/index.d.ts

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

package/dist/types/ast-nodes/object-entry.d.ts

@@ -0,0 +1,6 @@
+import type { Rule } from 'eslint';
+import type { Property, SpreadElement } from 'eslint-codemod-utils';
+declare const ObjectEntry: {
+    deleteEntry(node: Property | SpreadElement, context: Rule.RuleContext, fixer: Rule.RuleFixer): Rule.Fix;
+};
+export { ObjectEntry };

package/dist/types/ast-nodes/object.d.ts

@@ -14,7 +14,7 @@ declare const ASTObjectExpression: {
      */
     isFlat(node: ObjectExpression): boolean;
     /**
-     * Returns a key-value pair like: `padding: '8px'` from: `{ padding: '8px' }`.
+     * Returns the first Property node from an Object that matches the provided name.
      */
     getEntryByPropertyName(node: ObjectExpression, name: string): Property | undefined;
     deleteEntry(node: ObjectExpression, name: string, fixer: Rule.RuleFixer): Rule.Fix[];

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

@@ -32,6 +32,7 @@ export declare const configs: {
             '@atlaskit/design-system/use-href-in-link-item': string;
             '@atlaskit/design-system/use-primitives': string;
             '@atlaskit/design-system/use-primitives-text': string;
+            '@atlaskit/design-system/use-tokens-typography': string;
             '@atlaskit/design-system/use-visually-hidden': string;
         };
     };

package/dist/types/presets/all.codegen.d.ts

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::bcb633b9d5c2def00d43b11139433c5c>>
+ * @codegen <<SignedSource::d90c2cf5e100daf98915f9467f2e5663>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 declare const _default: {
@@ -35,6 +35,7 @@ declare const _default: {
         '@atlaskit/design-system/use-href-in-link-item': string;
         '@atlaskit/design-system/use-primitives': string;
         '@atlaskit/design-system/use-primitives-text': string;
+        '@atlaskit/design-system/use-tokens-typography': string;
         '@atlaskit/design-system/use-visually-hidden': string;
     };
 };

package/dist/types/rules/ensure-design-token-usage/types.d.ts

@@ -1,4 +1,4 @@
-export type Domains = ('color' | 'spacing' | 'typography' | 'shape')[];
+export type Domains = ('color' | 'spacing' | 'shape')[];
 export type RuleConfig = {
     domains: Domains;
     applyImport?: boolean;

package/dist/types/rules/ensure-design-token-usage/utils.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from 'eslint';
-import { EslintNode, ObjectExpression, TaggedTemplateExpression } from 'eslint-codemod-utils';
+import { EslintNode, ObjectExpression, Property, SpreadElement, TaggedTemplateExpression } from 'eslint-codemod-utils';
 import { Domains } from './types';
 export type ProcessedCSSLines = [string, string][];
 export declare function insertTokensImport(fixer: Rule.RuleFixer): Rule.Fix;
@@ -16,8 +16,8 @@ export declare const isSpacingProperty: (propertyName: string) => boolean;
  * For input `-${gridSize / 2}px ${token(...)} 18px -> [`-${gridSize / 2}px`, `${token(...)}`, `18px`]
  */
 export declare const splitShorthandValues: (str: string) => string[];
-export declare const getValueFromShorthand: (str: unknown) => any[];
-export declare const getValue: (node: EslintNode, context: Rule.RuleContext) => string | number | any[] | null | undefined;
+export declare const getValueFromShorthand: (str: unknown) => (string | number)[];
+export declare const getValue: (node: EslintNode, context: Rule.RuleContext) => string | number | (string | number)[] | null | undefined;
 export declare const getRawExpression: (node: EslintNode, context: Rule.RuleContext) => string | null;
 /**
  * @example
@@ -43,34 +43,33 @@ export declare const isAuto: (value: string | number | boolean | RegExp | null |
 export declare const convertHyphenatedNameToCamelCase: (prop: string) => string;
 /**
  * @param node
- * @returns The furthest parent node that is on the same line as the input node
+ * @returns The furthest parent node that is on the same line as the input node.
  */
 export declare const findParentNodeForLine: (node: Rule.Node) => Rule.Node;
 /**
- * Returns an array of domains that are relevant to the provided property based on the rule options
+ * Returns an array of domains that are relevant to the provided property based on the rule options.
  * @param propertyName camelCase CSS property
- * @param targetOptions Array containing the types of properties that should be included in the rule
+ * @param targetOptions Array containing the types of properties that should be included in the rule.
  * @example
  * ```
  * propertyName: padding, targetOptions: ['spacing'] -> returns ['spacing']
- * propertyName: fontWeight, targetOptions: ['spacing', 'typography'] -> returns ['typography']
- * propertyName: backgroundColor, targetOptions: ['spacing', 'typography'] -> returns []
+ * propertyName: backgroundColor, targetOptions: ['spacing'] -> returns []
  * propertyName: backgroundColor, targetOptions: ['color', 'spacing'] -> returns ['color']
  * ```
  */
 export declare function getDomainsForProperty(propertyName: string, targetOptions: Domains): Domains;
 /**
  * Function that removes JS comments from a string of code,
- * sometimes makers will have single or multiline comments in their tagged template literals styles, this can mess with our parsing logic
+ * sometimes makers will have single or multiline comments in their tagged template literals styles, this can mess with our parsing logic.
  */
 export declare function cleanComments(str: string): string;
 /**
  * Returns an array of tuples representing a processed css within `TaggedTemplateExpression` node.
- * each element of the array is a tuple `[string, string]`,
+ * Each element of the array is a tuple `[string, string]`,
  * where the first element is the processed css line with computed values
- * and the second element of the tuple is the original css line from source
- * @param node TaggedTemplateExpression node
- * @param context Rule.RuleContext
+ * and the second element of the tuple is the original css line from source.
+ * @param node TaggedTemplateExpression node.
+ * @param context Rule.RuleContext.
  * @example
  * ```
  * `[['padding: 8', 'padding: ${gridSize()}'], ['margin: 6', 'margin: 6px' ]]`
@@ -91,13 +90,13 @@ export declare function getTokenNodeForValue(propertyName: string, value: string
 export declare function getFontSizeValueInScope(cssProperties: ProcessedCSSLines): number | undefined;
 /**
  * Attempts to remove all non-essential words & characters from a style block.
- * Including selectors and queries
+ * Including selectors and queries.
  * @param styleString string of css properties
  */
 export declare function splitCssProperties(styleString: string): string[];
 /**
- * returns whether the current string is a token value
- * @param originalVaue string representing a css property value e.g 1em, 12px
+ * Returns whether the current string is a token value.
+ * @param originalVaue string representing a css property value e.g 1em, 12px.
  */
 export declare function isTokenValueString(originalValue: string): boolean;
 export declare function includesTokenString(originalValue: string): boolean;
@@ -106,17 +105,18 @@ export declare function includesTokenString(originalValue: string): boolean;
  *
  * -> for pixels this '8px'
  * -> for weights     '400'
- * -> for family      'Arial'
+ * -> for family      'Arial'.
  *
  * @internal
  */
-export declare function normaliseValue(propertyName: string, value: string): string;
+export declare function normaliseValue(propertyName: string, value: string | number): string;
 export declare function findTokenNameByPropertyValue(propertyName: string, value: string): string | undefined;
 /**
  * Returns a stringifiable node with the token expression corresponding to its matching token.
- * if no token found for the pair the function returns undefined
- * @param propertyName string camelCased css property
- * @param value the computed value e.g '8px' -> '8'
+ * If no token found for the pair the function returns undefined.
+ * @param propertyName string camelCased css property.
+ * @param value The computed value e.g '8px' -> '8'.
  */
 export declare function getTokenReplacement(propertyName: string, value: string): import("eslint-codemod-utils").StringableASTNode<import("estree").SimpleCallExpression> | undefined;
-export declare function getFontSizeFromNode(parentNode: ObjectExpression & Rule.NodeParentExtension, context: Rule.RuleContext): any;
+export declare function getPropertyNodeFromParent(property: string, parentNode: ObjectExpression & Rule.NodeParentExtension): Property | SpreadElement | undefined;
+export declare function getValueForPropertyNode(propertyNode: Property | SpreadElement, context: Rule.RuleContext): string | number | null | undefined;

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

@@ -32,6 +32,7 @@ declare const _default: {
     'use-href-in-link-item': import("eslint").Rule.RuleModule;
     'use-primitives': import("eslint").Rule.RuleModule;
     'use-primitives-text': import("eslint").Rule.RuleModule;
+    'use-tokens-typography': import("eslint").Rule.RuleModule;
     'use-visually-hidden': import("eslint").Rule.RuleModule;
 };
 export default _default;

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

@@ -1,4 +1,4 @@
-type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties';
+type Pattern = 'compiled-css-function' | 'compiled-styled-object' | 'css-template-literal' | 'css-property-with-tokens' | 'css-property-multiple-values' | 'multiple-properties' | 'dimension-properties' | 'jsx-order-fix';
 export interface RuleConfig {
     patterns: Pattern[];
 }

package/dist/types/rules/use-primitives/transformers/compiled-styled/find-valid-jsx-usage-to-transform.d.ts

@@ -3,5 +3,7 @@ import { JSXOpeningElement } from 'eslint-codemod-utils';
 /**
  * Given a component name finds its JSX usages and performs some
  * additional validations to ensure transformation can be done correctly
+ *
+ * anyOrder: if true, the order of the references doesn't matter (JSX or style declaration)
  */
-export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;
+export declare const findValidJsxUsageToTransform: (componentName: string, scope: Scope.Scope, anyOrder?: boolean) => (JSXOpeningElement & Rule.NodeParentExtension) | undefined;

package/dist/types/rules/use-primitives/transformers/compiled-styled/index.d.ts

@@ -20,6 +20,6 @@ export declare const CompiledStyled: {
      * All required validation steps have been taken care of before this
      * transformer is called, so it just goes ahead providing all necessary fixes
      */
-    _fix(refs: Refs, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+    _fix(refs: Refs, context: Rule.RuleContext): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives/transformers/emotion-css/index.d.ts

@@ -5,12 +5,11 @@ interface MetaData {
     context: Rule.RuleContext;
     config: RuleConfig;
 }
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
 export declare const EmotionCSS: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: Rule.Node, { context, config }: MetaData): boolean;
     _fix(node: JSXElement, { context }: {
         context: Rule.RuleContext;
-    }): FixFunction;
+    }): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives-text/config/index.d.ts

@@ -1,6 +1,7 @@
 type Pattern = 'paragraph-elements' | 'span-elements' | 'strong-elements' | 'emphasis-elements';
 export interface RuleConfig {
     patterns: Pattern[];
+    inheritColor: boolean;
 }
 export declare const getConfig: (overrides: Partial<RuleConfig>) => Required<RuleConfig>;
 export {};

package/dist/types/rules/use-primitives-text/transformers/common.d.ts

@@ -1,5 +1,11 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
+import { RuleConfig } from '../config';
+export type MetaData = {
+    context: Rule.RuleContext;
+    config: RuleConfig;
+};
 export declare function updateTestIdAttributeFix(node: JSXElement, fixer: Rule.RuleFixer): Rule.Fix | undefined;
+export declare function addColorInheritAttributeFix(node: JSXElement, config: RuleConfig, fixer: Rule.RuleFixer): Rule.Fix | undefined;
 export declare const allowedAttrs: string[];
 export declare function hasTextChildrenOnly(node: JSXElement): boolean;

package/dist/types/rules/use-primitives-text/transformers/emphasis-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const EmphasisElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};

package/dist/types/rules/use-primitives-text/transformers/paragraph-elements.d.ts

@@ -1,17 +1,12 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-type MetaData = {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-};
+import { type MetaData } from './common';
 type CheckResult = {
     success: boolean;
     refs: {
         siblings: JSXElement['children'];
     };
 };
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
 export declare const ParagraphElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement & {
@@ -19,14 +14,11 @@ export declare const ParagraphElements: {
     }, { context, config }: MetaData): CheckResult;
     _fixSingle(node: JSXElement & {
         parent: Rule.Node;
-    }, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    }, { context, config }: MetaData): Rule.ReportFixer;
     _fixMultiple(node: JSXElement & {
         parent: Rule.Node;
-    }, { context, refs }: {
-        context: Rule.RuleContext;
+    }, { context, config, refs }: MetaData & {
         refs: CheckResult['refs'];
-    }): FixFunction;
+    }): Rule.ReportFixer;
 };
 export {};

package/dist/types/rules/use-primitives-text/transformers/span-elements.d.ts

@@ -1,16 +1,8 @@
 import type { Rule } from 'eslint';
 import { JSXElement } from 'eslint-codemod-utils';
-import { RuleConfig } from '../config';
-interface MetaData {
-    context: Rule.RuleContext;
-    config: RuleConfig;
-}
-type FixFunction = (fixer: Rule.RuleFixer) => Rule.Fix[];
+import { type MetaData } from './common';
 export declare const SpanElements: {
     lint(node: Rule.Node, { context, config }: MetaData): void;
     _check(node: JSXElement, { context, config }: MetaData): boolean;
-    _fix(node: JSXElement, { context }: {
-        context: Rule.RuleContext;
-    }): FixFunction;
+    _fix(node: JSXElement, { context, config }: MetaData): Rule.ReportFixer;
 };
-export {};