@atlaskit/eslint-plugin-design-system 14.1.0 → 14.3.0

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

@@ -0,0 +1,37 @@
+import { getIdentifierInParentScope, identifier } from 'eslint-codemod-utils';
+import { getScope } from '@atlaskit/eslint-utils/context-compat';
+import { getAttributeValueIdentifier } from '../utils/get-attribute-value-identifier';
+import { getFunctionArgumentAtPos } from '../utils/get-function-argument-at-pos';
+import { getJSXAttributeByName } from '../utils/get-jsx-attribute-by-name';
+import { getVariableDefinitionValue } from '../utils/get-variable-definition-value';
+import { styledObjectToXcssTokens } from './styled-object-to-xcss-tokens';
+export const cssToXcssTransformer = (node, context, fixer) => {
+  /**
+   * Note: The logic here is very similar to the logic in `shouldSuggestBox`. i.e.
+   * 1. Find the `css` attr
+   * 2. Find the variableName (`myStyles` in `css={myStyles}`)
+   * 3. Find the `const myStyles = css({ padding: '8px' })`
+   * 4. Find the style object `{ padding: '8px' }`
+   *
+   * The only difference is, we've already performed very defensive checks for these steps in `shouldSuggestBox`,
+   * so there's no need to do those checks here.
+   *
+   * The repetition could be avoided by combining the 'shouldSuggest' and 'fixCode' steps. However, there are tradeoffs
+   * to that approach (mainly poor separation of concerns). I'm un-opinionated about which strategy we use. I just opted
+   * for this because the original `use-primitives` rule did this.
+   */
+  const cssAttr = getJSXAttributeByName(node.openingElement, 'css');
+  const cssVariableName = getAttributeValueIdentifier(cssAttr);
+  if (!cssVariableName) {
+    return [];
+  }
+  const cssVariableDefinition = getIdentifierInParentScope(getScope(context, node), cssVariableName);
+  const cssVariableValue = getVariableDefinitionValue(cssVariableDefinition);
+  if (!cssVariableValue) {
+    return [];
+  }
+  const cssObjectExpression = getFunctionArgumentAtPos(cssVariableValue, 0);
+  return [
+  // Update `css` function name to `xcss`.
+  fixer.replaceText(cssVariableValue.node.init.callee, identifier('xcss').toString()), ...styledObjectToXcssTokens(cssObjectExpression, fixer)];
+};

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

@@ -4,13 +4,13 @@ import { getIdentifierInParentScope, isNodeOfType } from 'eslint-codemod-utils';
 import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { FunctionCall } from '../../../../ast-nodes/function-call';
 import { JSXAttribute as JSXAttributeHelper } from '../../../../ast-nodes/jsx-attribute';
-import { JSXElement as JSXElementHelper } from '../../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../../ast-nodes/jsx-element-helper';
 import { Root } from '../../../../ast-nodes/root';
 import { getVariableDefinitionValue } from '../../utils/get-variable-definition-value';
 import { getVariableUsagesCount } from '../../utils/get-variable-usage-count';
 import { isValidCssPropertiesToTransform } from '../../utils/is-valid-css-properties-to-transform';
 import { validateStyles } from '../../utils/validate-styles';
-import { cssToXcssTransformer } from '../css-to-xcss';
+import { cssToXcssTransformer } from '../css-to-xcss-transformer';
 import { attributes } from './attributes';
 import { elements } from './elements';
 export const EmotionCSS = {

package/dist/es2019/rules/use-primitives/transformers/styled-object-to-xcss-tokens.js

@@ -0,0 +1,34 @@
+import { isNodeOfType, literal } from 'eslint-codemod-utils';
+import { supportedStylesMap } from './supported-styles-map';
+
+// e.g. `padding: '8px'`. For clarity, it's renamed to `entry` inside the `.map()`.
+export const styledObjectToXcssTokens = (styles, fixer) => {
+  return styles.properties.map(entry => {
+    if (!isNodeOfType(entry, 'Property')) {
+      return;
+    }
+    if (!isNodeOfType(entry.key, 'Identifier')) {
+      return;
+    }
+
+    // maps literal values like: 8px to 'space.100'
+    if (isNodeOfType(entry.value, 'Literal')) {
+      const value = entry.value.value;
+      if (typeof value !== 'string') {
+        return;
+      }
+      return fixer.replaceText(entry.value, literal(`'${supportedStylesMap[entry.key.name][value]}'`).toString());
+    }
+    // maps token calls like: token('space.100') to 'space.100'
+    if (isNodeOfType(entry.value, 'CallExpression')) {
+      const callExpression = entry.value;
+      // skip if not a call to `token`
+      if (!isNodeOfType(callExpression.callee, 'Identifier') || callExpression.callee.name !== 'token' || !isNodeOfType(callExpression.arguments[0], 'Literal')) {
+        return;
+      }
+      // the first argument of `token` is the token name and
+      // can be given directly to `xcss` as it has been validated already.
+      return fixer.replaceText(entry.value, literal(`'${callExpression.arguments[0].value}'`).toString());
+    }
+  });
+};

package/dist/es2019/rules/use-primitives/transformers/supported-styles-map.js

@@ -0,0 +1,28 @@
+import { spaceTokenMap } from './space-token-map';
+import { spaceTokenPositiveMap } from './space-token-positive-map';
+import { supportedDimensionAttributesMap } from './supported-dimension-attributes-map';
+export const supportedStylesMap = {
+  padding: spaceTokenPositiveMap,
+  paddingBlock: spaceTokenPositiveMap,
+  paddingBlockEnd: spaceTokenPositiveMap,
+  paddingBlockStart: spaceTokenPositiveMap,
+  paddingBottom: spaceTokenPositiveMap,
+  paddingInline: spaceTokenPositiveMap,
+  paddingInlineEnd: spaceTokenPositiveMap,
+  paddingInlineStart: spaceTokenPositiveMap,
+  paddingLeft: spaceTokenPositiveMap,
+  paddingRight: spaceTokenPositiveMap,
+  paddingTop: spaceTokenPositiveMap,
+  margin: spaceTokenMap,
+  marginBlock: spaceTokenMap,
+  marginBlockEnd: spaceTokenMap,
+  marginBlockStart: spaceTokenMap,
+  marginBottom: spaceTokenMap,
+  marginInline: spaceTokenMap,
+  marginInlineEnd: spaceTokenMap,
+  marginInlineStart: spaceTokenMap,
+  marginLeft: spaceTokenMap,
+  marginRight: spaceTokenMap,
+  marginTop: spaceTokenMap,
+  ...supportedDimensionAttributesMap
+};

package/dist/es2019/rules/use-primitives/utils/is-valid-css-properties-to-transform.js

@@ -1,7 +1,7 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { Object as ObjectHelper } from '../../../ast-nodes/object';
-import { supportedStylesMap } from '../transformers/css-to-xcss';
 import { supportedDimensionAttributesMap } from '../transformers/supported-dimension-attributes-map';
+import { supportedStylesMap } from '../transformers/supported-styles-map';
 import { convertASTObjectExpressionToJSObject } from './convert-ast-object-expression-to-js-object';
 export const isValidCssPropertiesToTransform = (node, config) => {
   if (!node) {

package/dist/es2019/rules/use-primitives/utils/validate-styles.js

@@ -2,9 +2,9 @@ import { isNodeOfType } from 'eslint-codemod-utils';
 import { FunctionCall } from '../../../ast-nodes/function-call';
 import { Object as ObjectHelper } from '../../../ast-nodes/object';
 import { ObjectEntry } from '../../../ast-nodes/object-entry';
-import { supportedStylesMap } from '../transformers/css-to-xcss';
 import { spaceTokenMap } from '../transformers/space-token-map';
 import { supportedDimensionAttributesMap } from '../transformers/supported-dimension-attributes-map';
+import { supportedStylesMap } from '../transformers/supported-styles-map';
 export const validateStyles = (node, config) => {
   if (!node) {
     return false;

package/dist/es2019/rules/use-primitives-text/config/{index.js → get-config.js}

@@ -1,12 +1,3 @@
-export const PATTERNS = [
-// <p>text</p>
-'paragraph-elements',
-// <span>text</span>
-'span-elements',
-// <strong>text</strong>
-'strong-elements',
-// <em>text</em>
-'emphasis-elements'];
 const defaults = {
   failSilently: false,
   patterns: ['paragraph-elements', 'span-elements', 'strong-elements', 'emphasis-elements'],

package/dist/es2019/rules/use-primitives-text/config/patterns.js

@@ -0,0 +1,9 @@
+export const PATTERNS = [
+// <p>text</p>
+'paragraph-elements',
+// <span>text</span>
+'span-elements',
+// <strong>text</strong>
+'strong-elements',
+// <em>text</em>
+'emphasis-elements'];

package/dist/es2019/rules/use-primitives-text/config/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,6 +1,7 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
-import { getConfig, PATTERNS } from './config';
+import { getConfig } from './config/get-config';
+import { PATTERNS } from './config/patterns';
 import { EmphasisElements } from './transformers/emphasis-elements';
 import { ParagraphElements } from './transformers/paragraph-elements';
 import { SpanElements } from './transformers/span-elements';

package/dist/es2019/rules/use-primitives-text/transformers/add-color-inherit-attribute-fix.js

@@ -1,4 +1,4 @@
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 // Add color="inherit" prop depending on config
 export function addColorInheritAttributeFix(node, config, fixer) {
   if (!config.inheritColor) {

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

@@ -2,7 +2,7 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 import { Root } from '../../../ast-nodes/root';
 import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
 import { allowedAttrs } from './allowed-attrs';

package/dist/es2019/rules/use-primitives-text/transformers/has-text-children-only.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { FunctionCall } from '../../../ast-nodes/function-call';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 
 // The use of `<FormattedMessage ... />` component and `{formatMessage(...)}` are allowed as these are used for i18n
 export function hasTextChildrenOnly(node) {

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

@@ -2,7 +2,7 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 import { Root } from '../../../ast-nodes/root';
 import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
 import { allowedAttrs } from './allowed-attrs';

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

@@ -2,7 +2,7 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 import { Root } from '../../../ast-nodes/root';
 import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
 import { allowedAttrs } from './allowed-attrs';

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

@@ -2,7 +2,7 @@
 
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 import { Root } from '../../../ast-nodes/root';
 import { addColorInheritAttributeFix } from './add-color-inherit-attribute-fix';
 import { allowedAttrs } from './allowed-attrs';

package/dist/es2019/rules/use-primitives-text/transformers/update-test-id-attribute-fix.js

@@ -1,5 +1,5 @@
 import { JSXAttribute } from '../../../ast-nodes/jsx-attribute';
-import { JSXElement as JSXElementHelper } from '../../../ast-nodes/jsx-element';
+import { JSXElementHelper } from '../../../ast-nodes/jsx-element-helper';
 
 // Rename data-testid prop to testId if present
 export function updateTestIdAttributeFix(node, fixer) {

package/dist/es2019/rules/use-should-render-to-parent/add-prop.js

@@ -0,0 +1,3 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+const PROP_NAME = 'shouldRenderToParent';
+export const addProp = `Add \`${PROP_NAME}\` prop.`;

package/dist/es2019/rules/use-should-render-to-parent/index.js

@@ -1,13 +1,29 @@
 // eslint-disable-next-line import/no-extraneous-dependencies
 
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
+import { addProp } from './add-prop';
+import { setPropToTrue } from './set-prop-to-true';
 export const RULE_NAME = 'use-should-render-to-parent';
 const PROP_NAME = 'shouldRenderToParent';
 const message = `Setting the \`${PROP_NAME}\` prop to anything other than \`true\` causes accessibility issues. Only set to \`false\` as a last resort.`;
-export const addProp = `Add \`${PROP_NAME}\` prop.`;
-export const setPropToTrue = `Set \`${PROP_NAME}\` prop to \`true\`.`;
-const components = ['@atlaskit/popup', '@atlaskit/dropdown-menu'];
+const components = {
+  '@atlaskit/popup': {
+    default: true,
+    named: 'Popup'
+  },
+  '@atlaskit/dropdown-menu': {
+    default: true
+  },
+  '@atlassian/entry-points/dropdown-trigger': {
+    default: false,
+    named: 'DropdownTrigger'
+  },
+  '@atlassian/entry-points/popup-trigger': {
+    default: false,
+    named: 'PopupTrigger'
+  }
+};
 const rule = createLintRule({
   meta: {
     name: RULE_NAME,
@@ -27,26 +43,33 @@ const rule = createLintRule({
     let componentLocalName;
     return {
       ImportDeclaration(node) {
+        var _components$source;
         const source = node.source.value;
         if (typeof source !== 'string') {
           return;
         }
-        if (!components.includes(source)) {
+        if (!(source in components)) {
           return;
         }
         if (!node.specifiers.length) {
           return;
         }
         const defaultImport = node.specifiers.filter(spec => spec.type === 'ImportDefaultSpecifier');
-        const namedImport = node.specifiers.filter(spec => spec.type === 'ImportSpecifier');
-
-        // If popup or dropdown menu and using a default import
-        if (defaultImport.length && defaultImport[0].local) {
+        const namedImports = node.specifiers.filter(spec => spec.type === 'ImportSpecifier');
+        if (defaultImport.length && defaultImport[0].local && (_components$source = components[source]) !== null && _components$source !== void 0 && _components$source.default) {
           componentLocalName = defaultImport[0].local.name;
-          // or if popup and using a named import
-        } else if (namedImport.length && namedImport[0].type === 'ImportSpecifier' && 'name' in namedImport[0].imported && namedImport[0].imported.name === 'Popup') {
-          componentLocalName = namedImport[0].local.name;
         }
+        if (!namedImports.length) {
+          return;
+        }
+
+        // Iterate through all of them, only one should ever be found
+        namedImports.forEach(namedImport => {
+          var _components$source2;
+          if (namedImport.type === 'ImportSpecifier' && 'name' in namedImport.imported && namedImport.imported.name === ((_components$source2 = components[source]) === null || _components$source2 === void 0 ? void 0 : _components$source2.named)) {
+            componentLocalName = namedImport.local.name;
+          }
+        });
       },
       JSXElement(node) {
         if (!isNodeOfType(node, 'JSXElement')) {
@@ -94,4 +117,6 @@ const rule = createLintRule({
     };
   }
 });
-export default rule;
+export default rule;
+export { addProp } from './add-prop';
+export { setPropToTrue } from './set-prop-to-true';

package/dist/es2019/rules/use-should-render-to-parent/set-prop-to-true.js

@@ -0,0 +1,3 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+const PROP_NAME = 'shouldRenderToParent';
+export const setPropToTrue = `Set \`${PROP_NAME}\` prop to \`true\`.`;

package/dist/es2019/rules/use-simple-field/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 const FORM_PACKAGE = '@atlaskit/form';
 const MESSAGE_COMPONENTS = ['ErrorMessage', 'HelperMessage', 'ValidMessage'];
 export const convertField = 'Convert field to simple field';

package/dist/es2019/rules/use-simple-form/index.js

@@ -1,7 +1,7 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
+import { topLevelAttributeNames } from './top-level-attribute-names';
 const FORM_PACKAGE = '@atlaskit/form';
-export const topLevelAttributeNames = ['autocomplete', 'id', 'label', 'labelId', 'onKeyDown', 'onSubmit', 'name', 'noValidate', 'ref', 'xcss'];
 export const convertForm = 'Convert form to simple form';
 const rule = createLintRule({
   meta: {
@@ -147,4 +147,5 @@ const rule = createLintRule({
     };
   }
 });
-export default rule;
+export default rule;
+export { topLevelAttributeNames } from './top-level-attribute-names';

package/dist/es2019/rules/use-simple-form/top-level-attribute-names.js

@@ -0,0 +1 @@
+export const topLevelAttributeNames = ['autocomplete', 'id', 'label', 'labelId', 'onKeyDown', 'onSubmit', 'name', 'noValidate', 'ref', 'xcss'];

package/dist/es2019/rules/use-spotlight-package/index.js

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { ImportDeclaration } from './linters/import-declaration';
 const rule = createLintRule({
   meta: {

package/dist/es2019/rules/use-tag-group-label/index.js

@@ -1,5 +1,5 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 const elementsAccessibleNameProps = ['label', 'titleId'];
 const rule = createLintRule({
   meta: {

package/dist/es2019/rules/use-textfield-autocomplete/index.js

@@ -1,7 +1,7 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { JSXAttribute } from '../../ast-nodes/jsx-attribute';
-import { JSXElementHelper } from '../../ast-nodes/jsx-element';
-import { createLintRule } from '../utils/create-rule';
+import { JSXElementHelper } from '../../ast-nodes/jsx-element-helper';
+import { createLintRule } from '../utils/create-lint-rule';
 const TEXTFIELD_PACKAGE = '@atlaskit/textfield';
 const TYPE_PROP = 'type';
 const AUTOCOMPLETE_PROP = 'autoComplete';

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

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { StyleProperty } from './transformers';
 const rule = createLintRule({
   meta: {

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

@@ -1,4 +1,4 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { StyleProperty } from './transformers/style-property';
 const rule = createLintRule({
   meta: {

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

@@ -0,0 +1,10 @@
+/* eslint-disable @atlassian/tangerine/import/entry-points */
+
+const defaultConfig = {
+  failSilently: false,
+  enableUnsafeAutofix: false,
+  patterns: ['style-object', 'font-weight', 'font-family', 'untokenized-properties', 'banned-properties', 'restricted-capitalisation']
+};
+export const getConfig = overrides => {
+  return Object.assign({}, defaultConfig, overrides);
+};

package/dist/es2019/rules/use-tokens-typography/config/{index.js → rule-schema.js}

@@ -20,12 +20,4 @@ export const ruleSchema = {
       }
     }
   }
-};
-const defaultConfig = {
-  failSilently: false,
-  enableUnsafeAutofix: false,
-  patterns: ['style-object', 'font-weight', 'font-family', 'untokenized-properties', 'banned-properties', 'restricted-capitalisation']
-};
-export const getConfig = overrides => {
-  return Object.assign({}, defaultConfig, overrides);
 };

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

@@ -0,0 +1,2 @@
+import { fontWeightMap } from './font-weight-map';
+export const defaultFontWeight = fontWeightMap.regular;

package/dist/es2019/rules/use-tokens-typography/find-font-weight-token-for-value.js

@@ -0,0 +1,12 @@
+import { fontWeightTokens } from './font-weight-tokens';
+export function findFontWeightTokenForValue(fontWeight, tokens = fontWeightTokens) {
+  if (fontWeight === 'normal') {
+    fontWeight = '400';
+  }
+
+  // Match bold and 700 to 653 to match with bold weight refreshed typography
+  if (fontWeight === 'bold' || fontWeight === '700') {
+    fontWeight = '653';
+  }
+  return tokens.find(token => token.values.fontWeight === fontWeight);
+}

package/dist/es2019/rules/use-tokens-typography/find-typography-token-for-values.js

@@ -0,0 +1,11 @@
+import { typographyValueToToken } from './typography-value-to-token';
+export function findTypographyTokenForValues(fontSize, lineHeight) {
+  // Match 11px to 12px as this is what happened when transitioning from legacy to refreshed typography
+  if (fontSize === '11px') {
+    fontSize = '12px';
+  }
+  let matchingTokens = typographyValueToToken.filter(token => token.values.fontSize === fontSize)
+  // If lineHeight == 1, we don't match to a token
+  .filter(() => lineHeight === '1' ? false : true);
+  return matchingTokens;
+}

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

@@ -0,0 +1,6 @@
+export const fontWeightMap = {
+  regular: '400',
+  medium: '500',
+  semibold: '600',
+  bold: '700'
+};

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

@@ -0,0 +1,10 @@
+import { typography as typographyTokens } from '@atlaskit/tokens/tokens-raw';
+export const fontWeightTokens = typographyTokens.filter(token => token.attributes.group === 'fontWeight').map(token => {
+  return {
+    tokenName: token.cleanName,
+    tokenValue: token.value,
+    values: {
+      fontWeight: token.value
+    }
+  };
+});

package/dist/es2019/rules/use-tokens-typography/get-token-property.js

@@ -0,0 +1,33 @@
+import { callExpression, identifier, literal, memberExpression, property } from 'eslint-codemod-utils';
+function createMemberExpressionFromArray(array) {
+  if (array.length === 1) {
+    return identifier(array[0]);
+  }
+  const property = array.pop();
+  return memberExpression({
+    object: createMemberExpressionFromArray(array),
+    property: identifier(property)
+  });
+}
+function getTokenNode(tokenName, fallbackValue, isFallbackMember = false) {
+  const callExpressionArgs = [literal({
+    value: `'${tokenName}'`
+  })];
+  if (fallbackValue) {
+    const fallback = isFallbackMember ? createMemberExpressionFromArray(fallbackValue.split('.')) : literal(fallbackValue);
+    callExpressionArgs.push(fallback);
+  }
+  return callExpression({
+    callee: identifier({
+      name: 'token'
+    }),
+    arguments: callExpressionArgs,
+    optional: false
+  });
+}
+export function getTokenProperty(propertyName, tokenName, tokenFallback, isFallbackMember = false) {
+  return property({
+    key: identifier(propertyName),
+    value: getTokenNode(tokenName, tokenFallback, isFallbackMember)
+  });
+}

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

@@ -1,6 +1,7 @@
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
-import { getConfig, ruleSchema } from './config';
+import { getConfig } from './config/get-config';
+import { ruleSchema } from './config/rule-schema';
 import { BannedProperties } from './transformers/banned-properties';
 import { FontFamily } from './transformers/font-family';
 import { FontWeight } from './transformers/font-weight';

package/dist/es2019/rules/use-tokens-typography/transformers/banned-properties.js

@@ -1,8 +1,8 @@
 /* eslint-disable @repo/internal/react/require-jsdoc */
 
 import { isNodeOfType } from 'eslint-codemod-utils';
+import { isDecendantOfStyleBlock } from '../../utils/is-decendant-of-style-block';
 import { isDecendantOfType } from '../../utils/is-decendant-of-type';
-import { isDecendantOfStyleBlock } from '../../utils/is-node';
 export const BannedProperties = {
   lint(node, {
     context,

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

@@ -4,8 +4,8 @@ import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { Root } from '../../../ast-nodes/root';
 import { getNodeSource } from '../../utils/get-node-source';
+import { isDecendantOfStyleBlock } from '../../utils/is-decendant-of-style-block';
 import { isDecendantOfType } from '../../utils/is-decendant-of-type';
-import { isDecendantOfStyleBlock } from '../../utils/is-node';
 import { findFontFamilyTokenForValue } from '../find-font-family-token-for-value';
 import { insertTokensImport } from '../insert-tokens-import';
 export const FontFamily = {

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

@@ -4,10 +4,10 @@ import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { Root } from '../../../ast-nodes/root';
 import { getNodeSource } from '../../utils/get-node-source';
+import { isDecendantOfStyleBlock } from '../../utils/is-decendant-of-style-block';
 import { isDecendantOfType } from '../../utils/is-decendant-of-type';
-import { isDecendantOfStyleBlock } from '../../utils/is-node';
+import { findFontWeightTokenForValue } from '../find-font-weight-token-for-value';
 import { insertTokensImport } from '../insert-tokens-import';
-import { findFontWeightTokenForValue } from '../utils';
 export const FontWeight = {
   lint(node, {
     context,

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

@@ -5,18 +5,22 @@ import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { Object as ASTObject } from '../../../ast-nodes/object';
 import { ObjectEntry } from '../../../ast-nodes/object-entry';
 import { Root } from '../../../ast-nodes/root';
+import { getValueForPropertyNode } from '../../ensure-design-token-usage/get-value-for-property-node';
 import { normaliseValue } from '../../ensure-design-token-usage/normalise-value';
-import { getValueForPropertyNode } from '../../ensure-design-token-usage/utils';
 import { isDecendantOfGlobalToken } from '../../utils/is-decendant-of-global-token';
+import { isDecendantOfStyleBlock } from '../../utils/is-decendant-of-style-block';
 import { isDecendantOfType } from '../../utils/is-decendant-of-type';
-import { isDecendantOfStyleBlock } from '../../utils/is-node';
 import { convertPropertyNodeToStringableNode } from '../convert-property-node-to-stringable-node';
+import { defaultFontWeight } from '../default-font-weight';
+import { findFontWeightTokenForValue } from '../find-font-weight-token-for-value';
+import { findTypographyTokenForValues } from '../find-typography-token-for-values';
+import { fontWeightMap } from '../font-weight-map';
 import { getLiteralProperty } from '../get-literal-property';
+import { getTokenProperty } from '../get-token-property';
 import { insertTokensImport } from '../insert-tokens-import';
 import { isValidPropertyNode } from '../is-valid-property-node';
 import { isValidTypographyToken } from '../is-valid-typography-token';
 import { notUndefined } from '../not-undefined';
-import { defaultFontWeight, findFontWeightTokenForValue, findTypographyTokenForValues, fontWeightMap, getTokenProperty } from '../utils';
 export const StyleObject = {
   lint(node, {
     context,

package/dist/es2019/rules/use-tokens-typography/transformers/untokenized-properties.js

@@ -3,8 +3,8 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { getNodeSource } from '../../utils/get-node-source';
+import { isDecendantOfStyleBlock } from '../../utils/is-decendant-of-style-block';
 import { isDecendantOfType } from '../../utils/is-decendant-of-type';
-import { isDecendantOfStyleBlock } from '../../utils/is-node';
 export const UntokenizedProperties = {
   lint(node, {
     context,