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

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-tokens-typography/config/index.d.ts

@@ -0,0 +1,6 @@
+import { JSONSchema4 } from '@typescript-eslint/utils/dist/json-schema';
+export type RuleConfig = {
+    failSilently?: boolean;
+};
+export declare const ruleSchema: JSONSchema4;
+export declare const getConfig: (overrides: RuleConfig) => RuleConfig;

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

@@ -0,0 +1,11 @@
+import { RuleConfig } from './config';
+/**
+ * ESLint rules should NEVER throw exceptions, because that breaks the VSCode ESLint server
+ * (and probably the IntelliJ one too), which causes linting to fail in a file.
+ *
+ * It also breaks CI, which was the reason this error boundary was added. It's a final
+ * catch all.
+ */
+export declare const errorBoundary: (func: () => void, { config }: {
+    config: RuleConfig;
+}) => void;

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

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

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

@@ -0,0 +1,31 @@
+import type { Rule } from 'eslint';
+import { ImportDeclaration, ObjectExpression, Property, StringableASTNode } from 'eslint-codemod-utils';
+import { TokenValueMap } from '../utils';
+interface MetaData {
+    context: Rule.RuleContext;
+}
+interface Refs {
+    fontSizeNode: Property;
+    fontSizeRaw: string | number;
+    tokensImportNode: ImportDeclaration | undefined;
+}
+type Check = {
+    success: boolean;
+    refs?: Refs;
+};
+interface FixerRefs {
+    matchingToken: TokenValueMap;
+    nodesToReplace: Property[];
+    tokensImportNode: ImportDeclaration | undefined;
+    fontWeightReplacement: StringableASTNode<Property> | undefined;
+    fontFamilyReplacement: StringableASTNode<Property> | undefined;
+    fontStyleReplacement: StringableASTNode<Property> | undefined;
+}
+export declare const StyleObject: {
+    lint(node: Rule.Node, { context }: MetaData): {
+        success: boolean;
+    } | undefined;
+    _check(node: ObjectExpression & Rule.NodeParentExtension, { context }: MetaData): Check;
+    _fix(refs: FixerRefs, context: Rule.RuleContext): (fixer: Rule.RuleFixer) => Rule.Fix[];
+};
+export {};

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

@@ -0,0 +1,161 @@
+import { CallExpression, EslintNode, Property } from 'eslint-codemod-utils';
+export declare const typographyProperties: string[];
+export declare const isTypographyProperty: (propertyName: string) => boolean;
+export declare const isFontSize: (node: EslintNode) => node is CallExpression;
+export declare const isFontSizeSmall: (node: EslintNode) => node is CallExpression;
+export declare const isFontFamily: (node: EslintNode) => node is CallExpression;
+export declare const isCodeFontFamily: (node: EslintNode) => node is CallExpression;
+export type TokenValueMap = {
+    tokenName: string;
+    tokenValue: string;
+    values: {
+        fontSize?: string;
+        fontWeight?: string;
+        lineHeight?: string;
+    };
+};
+export declare const typographyValueToToken: TokenValueMap[];
+export declare function findTypographyTokenForValues(fontSize: string, lineHeight?: string): TokenValueMap[];
+export declare const fontWeightTokens: {
+    tokenName: string;
+    tokenValue: string;
+    values: {};
+}[];
+export declare function findFontWeightTokenForValue(fontWeight: string): {
+    tokenName: string;
+    tokenValue: string;
+    values: {};
+} | undefined;
+export declare const fontWeightMap: FontWeightMap;
+export type FontWeightMap = {
+    regular: string;
+    medium: string;
+    semibold: string;
+    bold: string;
+};
+export declare const defaultFontWeight: string;
+export declare const fontFamilyTokens: ({
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        responsiveSmallerVariant?: undefined;
+        deprecated?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            responsiveSmallerVariant?: undefined;
+            deprecated?: undefined;
+        };
+        value: string;
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        responsiveSmallerVariant: string;
+        deprecated?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            responsiveSmallerVariant: string;
+            deprecated?: undefined;
+        };
+        value: {
+            fontWeight: string;
+            fontSize: string;
+            lineHeight: string;
+            fontFamily: string;
+            fontStyle: string;
+            letterSpacing: string;
+        };
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        responsiveSmallerVariant?: undefined;
+        deprecated?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            responsiveSmallerVariant?: undefined;
+            deprecated?: undefined;
+        };
+        value: {
+            fontWeight: string;
+            fontSize: string;
+            lineHeight: string;
+            fontFamily: string;
+            fontStyle: string;
+            letterSpacing: string;
+        };
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+} | {
+    attributes: {
+        group: string;
+        state: string;
+        introduced: string;
+        description: string;
+        deprecated: string;
+        responsiveSmallerVariant?: undefined;
+    };
+    value: string;
+    filePath: string;
+    isSource: boolean;
+    original: {
+        attributes: {
+            group: string;
+            state: string;
+            introduced: string;
+            description: string;
+            deprecated: string;
+            responsiveSmallerVariant?: undefined;
+        };
+        value: string;
+    };
+    name: string;
+    path: string[];
+    cleanName: string;
+})[];
+export declare function findFontFamilyValueForToken(tokenName: string): string;
+export declare function notUndefined<V>(value: V | undefined): value is V;
+export declare function isValidPropertyNode(node: Property): boolean;
+export declare function getTokenProperty(propertyName: string, tokenName: string, tokenFallback: string): import("eslint-codemod-utils").StringableASTNode<Property>;
+export declare function getLiteralProperty(propertyName: string, propertyValue: string): import("eslint-codemod-utils").StringableASTNode<Property>;
+export declare function convertPropertyNodeToStringableNode(node: Property): import("eslint-codemod-utils").StringableASTNode<Property>;

package/dist/types-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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-ts4.5/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;