@atlaskit/eslint-plugin-design-system 14.2.0 → 14.3.1

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

@@ -2,31 +2,45 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { getImportSources } from '@atlaskit/eslint-utils/is-supported-import';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
-import { includesHardCodedColor } from '../utils/is-color';
+import { includesHardCodedColor } from '../utils/includes-hard-coded-color';
 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 { isDecendantOfXcssBlock } from '../utils/is-decendant-of-xcss-block';
-import { isDecendantOfStyleBlock } from '../utils/is-node';
-import { lintJSXIdentifierForColor, lintJSXLiteralForColor, lintJSXMemberForColor, lintObjectForColor, lintTemplateIdentifierForColor } from './color';
 import { convertHyphenatedNameToCamelCase } from './convert-hyphenated-name-to-camel-case';
+import { emToPixels } from './em-to-pixels';
+import { getDomainsForProperty } from './get-domains-for-property';
+import { getFontSizeValueInScope } from './get-font-size-value-in-scope';
+import { getPropertyNodeFromParent } from './get-property-node-from-parent';
+import { getTokenReplacement } from './get-token-replacement';
+import { getValueForPropertyNode } from './get-value-for-property-node';
+import { getValueFromShorthand } from './get-value-from-shorthand';
+import { getValueFromTemplateLiteralRaw } from './get-value-from-template-literal-raw';
 import { includesTokenString } from './includes-token-string';
 import { insertTokensImport } from './insert-tokens-import';
 import { isAuto } from './is-auto';
+import { isCalc } from './is-calc';
 import { isTokenValueString } from './is-token-value-string';
+import { isValidSpacingValue } from './is-valid-spacing-value';
 import { isZero } from './is-zero';
+import { lintJSXIdentifierForColor } from './lint-jsx-identifier-for-color';
+import { lintJSXLiteralForColor } from './lint-jsx-literal-for-color';
+import { lintJSXMemberForColor } from './lint-jsx-member-for-color';
+import { lintObjectForColor } from './lint-object-for-color';
+import { lintTemplateIdentifierForColor } from './lint-template-identifier-for-color';
+import { processCssNode } from './process-css-node';
 import ruleMeta from './rule-meta';
 import { lintObjectForSpacing } from './spacing';
 import { splitShorthandValues } from './split-shorthand-values';
-import { emToPixels, getDomainsForProperty, getFontSizeValueInScope, getPropertyNodeFromParent, getTokenReplacement, getValueForPropertyNode, getValueFromShorthand, getValueFromTemplateLiteralRaw, isCalc, isValidSpacingValue, processCssNode } from './utils';
 var defaultConfig = {
   domains: ['color', 'spacing'],
   applyImport: true,
   shouldEnforceFallbacks: false,
   failSilently: false
 };
-var createWithConfig = function createWithConfig(initialConfig) {
+export var createWithConfig = function createWithConfig(initialConfig) {
   return function (context) {
     // TODO: JFP-2823 - this type cast was added due to Jira's ESLint v9 migration
     var userConfig = context.options[0];
@@ -312,5 +326,4 @@ var rule = createLintRule({
   meta: ruleMeta,
   create: createWithConfig(defaultConfig)
 });
-export default rule;
-export { createWithConfig };
+export default rule;

package/dist/esm/rules/ensure-design-token-usage/is-border-size-property.js

@@ -0,0 +1,4 @@
+var borderSizeProperties = ['borderWidth', 'outlineWidth', 'borderRightWidth', 'borderLeftWidth', 'borderTopWidth', 'borderBottomWidth', 'borderInlineWidth', 'borderBlockWidth'];
+export function isBorderSizeProperty(propertyName) {
+  return borderSizeProperties.includes(propertyName);
+}

package/dist/esm/rules/ensure-design-token-usage/is-calc.js

@@ -0,0 +1,9 @@
+var calcRegex = /(^calc)/;
+export var isCalc = function isCalc(value) {
+  if (typeof value === 'string') {
+    if (calcRegex.test(value)) {
+      return true;
+    }
+  }
+  return false;
+};

package/dist/esm/rules/ensure-design-token-usage/is-radius-property.js

@@ -0,0 +1,4 @@
+var shapeProperties = ['borderTopLeftRadius', 'borderTopRightRadius', 'borderBottomRightRadius', 'borderBottomLeftRadius', 'borderRadius', 'borderStartStartRadius', 'borderStartEndRadius', 'borderEndStartRadius', 'borderEndEndRadius'];
+export function isRadiusProperty(propertyName) {
+  return shapeProperties.includes(propertyName);
+}

package/dist/esm/rules/ensure-design-token-usage/is-shape-property.js

@@ -0,0 +1,5 @@
+import { isBorderSizeProperty } from './is-border-size-property';
+import { isRadiusProperty } from './is-radius-property';
+export function isShapeProperty(propertyName) {
+  return isRadiusProperty(propertyName) || isBorderSizeProperty(propertyName);
+}

package/dist/esm/rules/ensure-design-token-usage/is-spacing-property.js

@@ -0,0 +1,4 @@
+var properties = ['padding', 'paddingBlock', 'paddingInline', 'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom', 'paddingInline', 'paddingInlineStart', 'paddingInlineEnd', 'paddingBlock', 'paddingBlockStart', 'paddingBlockEnd', 'marginLeft', 'marginTop', 'marginRight', 'marginBottom', 'marginInline', 'marginInlineStart', 'marginInlineEnd', 'marginBlock', 'marginBlockStart', 'marginBlockEnd', 'margin', 'gap', 'rowGap', 'gridRowGap', 'columnGap', 'gridColumnGap', 'top', 'left', 'right', 'bottom', 'inlineStart', 'inlineEnd', 'blockStart', 'blockEnd', 'outline-offset'];
+export var isSpacingProperty = function isSpacingProperty(propertyName) {
+  return properties.includes(propertyName);
+};

package/dist/esm/rules/ensure-design-token-usage/is-valid-spacing-value.js

@@ -0,0 +1,20 @@
+var emRegex = /(.*\d+)em$/;
+var invalidSpacingUnitRegex = /(\d+rem$)|(vw$)|(vh$)/;
+export var isValidSpacingValue = function isValidSpacingValue(value, fontSize) {
+  if (typeof value === 'string') {
+    if (invalidSpacingUnitRegex.test(value)) {
+      return false;
+    }
+  } else if (Array.isArray(value)) {
+    // could be array due to shorthand
+    for (var val in value) {
+      if (invalidSpacingUnitRegex.test(val)) {
+        return false;
+      }
+    }
+  }
+  if (emRegex.test(value) && typeof fontSize !== 'number') {
+    return false;
+  }
+  return true;
+};

package/dist/esm/rules/ensure-design-token-usage/lint-jsx-identifier-for-color.js

@@ -0,0 +1,23 @@
+import { getIsException } from '../utils/get-is-exception';
+import { includesHardCodedColor } from '../utils/includes-hard-coded-color';
+import { isLegacyColor } from '../utils/is-legacy-color';
+import { getTokenSuggestion } from './get-token-suggestion';
+// JSXExpressionContainer > Identifier
+export var lintJSXIdentifierForColor = function lintJSXIdentifierForColor(node, context, config) {
+  // To force the correct node type
+  if (node.type !== 'Identifier') {
+    return;
+  }
+  var isException = getIsException(config.exceptions);
+  if (isException(node)) {
+    return;
+  }
+  if (isLegacyColor(node.name) || includesHardCodedColor(node.name)) {
+    context.report({
+      messageId: 'hardCodedColor',
+      node: node,
+      suggest: getTokenSuggestion(node, node.name, config)
+    });
+    return;
+  }
+};

package/dist/esm/rules/ensure-design-token-usage/lint-jsx-literal-for-color.js

@@ -0,0 +1,146 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { getIsException } from '../utils/get-is-exception';
+import { includesHardCodedColor } from '../utils/includes-hard-coded-color';
+import { isDecendantOfPrimitive } from '../utils/is-decendant-of-primitive';
+import { isDecendantOfSvgElement } from '../utils/is-decendant-of-svg-element';
+import { isHardCodedColor } from '../utils/is-hard-coded-color';
+import { getTokenSuggestion } from './get-token-suggestion';
+/**
+ * Check if the JSXAttribute is a 'color' prop on a Tag component imported from @atlaskit/tag
+ */
+var isTagComponentColorProp = function isTagComponentColorProp(jsxAttributeNode, context) {
+  var _variable$defs;
+  if (!isNodeOfType(jsxAttributeNode, 'JSXAttribute')) {
+    return false;
+  }
+
+  // Check if the attribute name is 'color'
+  var attributeName = typeof jsxAttributeNode.name.name === 'string' ? jsxAttributeNode.name.name : jsxAttributeNode.name.name.name;
+  if (attributeName !== 'color') {
+    return false;
+  }
+
+  // Find the JSXOpeningElement
+  var currentNode = jsxAttributeNode.parent;
+  while (currentNode && !isNodeOfType(currentNode, 'JSXOpeningElement')) {
+    currentNode = currentNode.parent;
+  }
+  if (!currentNode || !isNodeOfType(currentNode, 'JSXOpeningElement')) {
+    return false;
+  }
+
+  // Get the component name
+  var elementName = isNodeOfType(currentNode.name, 'JSXIdentifier') ? currentNode.name.name : null;
+  if (!elementName) {
+    return false;
+  }
+
+  // Check if the component is imported from @atlaskit/tag (scope-based resolution)
+  var scope = getScope(context, jsxAttributeNode);
+  var variable = scope.variables.find(function (v) {
+    return v.name === elementName;
+  });
+  if (variable !== null && variable !== void 0 && (_variable$defs = variable.defs) !== null && _variable$defs !== void 0 && _variable$defs.length) {
+    var _iterator = _createForOfIteratorHelper(variable.defs),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var def = _step.value;
+        if (def.type === 'ImportBinding' && def.parent && isNodeOfType(def.parent, 'ImportDeclaration')) {
+          var importSource = def.parent.source.value;
+          if (typeof importSource === 'string' && importSource.match(/^@atlaskit\/tag(\/|$)/)) {
+            return true;
+          }
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  // Fallback: scan AST for ImportDeclaration (more reliable when scope differs e.g. in some monorepo/parser setups)
+  var sourceCode = getSourceCode(context);
+  var ast = sourceCode.ast;
+  if (ast !== null && ast !== void 0 && ast.body) {
+    var _iterator2 = _createForOfIteratorHelper(ast.body),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _node$source, _node$specifiers;
+        var node = _step2.value;
+        if (!isNodeOfType(node, 'ImportDeclaration')) {
+          continue;
+        }
+        var source = (_node$source = node.source) === null || _node$source === void 0 ? void 0 : _node$source.value;
+        if (typeof source !== 'string' || !source.match(/^@atlaskit\/tag(\/|$)/)) {
+          continue;
+        }
+        var hasMatchingImport = (_node$specifiers = node.specifiers) === null || _node$specifiers === void 0 ? void 0 : _node$specifiers.some(function (s) {
+          var _s$local, _s$local2;
+          return s.type === 'ImportDefaultSpecifier' && ((_s$local = s.local) === null || _s$local === void 0 ? void 0 : _s$local.name) === elementName || s.type === 'ImportSpecifier' && ((_s$local2 = s.local) === null || _s$local2 === void 0 ? void 0 : _s$local2.name) === elementName;
+        });
+        if (hasMatchingImport) {
+          return true;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+  return false;
+};
+
+// JSXAttribute > Literal
+export var lintJSXLiteralForColor = function lintJSXLiteralForColor(node, context, config) {
+  // To force the correct node type
+  if (node.type !== 'Literal') {
+    return;
+  }
+
+  // Changed this condition to properly handle both direct literals and expression containers
+  var parent = isNodeOfType(node.parent, 'JSXExpressionContainer') ? node.parent.parent : node.parent;
+  if (!isNodeOfType(parent, 'JSXAttribute')) {
+    return;
+  }
+  if (isDecendantOfSvgElement(parent)) {
+    return;
+  }
+
+  // Box backgroundColor prop accepts token names directly - don't lint against this
+  if (isDecendantOfPrimitive(parent, context)) {
+    return;
+  }
+  if (['alt', 'src', 'label', 'key', 'appearance'].includes(typeof parent.name.name === 'string' ? parent.name.name : parent.name.name.name)) {
+    return;
+  }
+  var isException = getIsException(config.exceptions);
+  if (isException(parent)) {
+    return;
+  }
+
+  // Bypass Tag component color prop from @atlaskit/tag
+  if (isTagComponentColorProp(parent, context)) {
+    return;
+  }
+
+  // We only care about hex values
+  if (typeof node.value !== 'string') {
+    return;
+  }
+  if (isHardCodedColor(node.value) || includesHardCodedColor(node.value)) {
+    context.report({
+      messageId: 'hardCodedColor',
+      node: node,
+      suggest: getTokenSuggestion(node, node.value, config)
+    });
+    return;
+  }
+};

package/dist/esm/rules/ensure-design-token-usage/lint-jsx-member-for-color.js

@@ -0,0 +1,22 @@
+import { node as generate, isNodeOfType } from 'eslint-codemod-utils';
+import { isLegacyColor } from '../utils/is-legacy-color';
+import { isLegacyNamedColor } from '../utils/is-legacy-named-color';
+import { getTokenSuggestion } from './get-token-suggestion';
+// JSXExpressionContainer > MemberExpression
+export var lintJSXMemberForColor = function lintJSXMemberForColor(node, context, config) {
+  // To force the correct node type
+  if (node.type !== 'MemberExpression') {
+    return;
+  }
+  if (!isNodeOfType(node.property, 'Identifier')) {
+    return;
+  }
+  if (isLegacyColor(node.property.name) || isNodeOfType(node.object, 'Identifier') && node.object.name === 'colors' && isLegacyNamedColor(node.property.name)) {
+    context.report({
+      messageId: 'hardCodedColor',
+      node: node,
+      suggest: getTokenSuggestion(node, generate(node).toString(), config)
+    });
+    return;
+  }
+};

package/dist/esm/rules/ensure-design-token-usage/lint-object-for-color.js

@@ -0,0 +1,88 @@
+import { node as generate, isNodeOfType } from 'eslint-codemod-utils';
+import { getIsException } from '../utils/get-is-exception';
+import { includesHardCodedColor } from '../utils/includes-hard-coded-color';
+import { isHardCodedColor } from '../utils/is-hard-coded-color';
+import { isLegacyColor } from '../utils/is-legacy-color';
+import { isLegacyNamedColor } from '../utils/is-legacy-named-color';
+import { getTokenSuggestion } from './get-token-suggestion';
+// ObjectExpression
+export var lintObjectForColor = function lintObjectForColor(propertyNode, context, config) {
+  var _identifierNode;
+  var propertyKey = '';
+  if (propertyNode.key.type === 'Identifier') {
+    propertyKey = propertyNode.key.name.toString();
+  }
+  var node = propertyNode.value;
+
+  // ObjectExpression > Property > Literal
+  if (node.type === 'Literal') {
+    var _node$value;
+    var nodeVal = ((_node$value = node.value) === null || _node$value === void 0 ? void 0 : _node$value.toString()) || '';
+    var _isException = getIsException(config.exceptions);
+    if ((isHardCodedColor(nodeVal) || includesHardCodedColor(nodeVal)) && !_isException(node)) {
+      context.report({
+        messageId: 'hardCodedColor',
+        node: node,
+        suggest: getTokenSuggestion(node, "'".concat(nodeVal, "'"), config)
+      });
+    }
+    return;
+  }
+  var isException = getIsException(config.exceptions);
+
+  // ObjectExpression > Property > CallExpression
+  if (node.type === 'CallExpression') {
+    if (!isNodeOfType(node.callee, 'Identifier')) {
+      return;
+    }
+    if (!isLegacyNamedColor(node.callee.name) || isException(node)) {
+      return;
+    }
+    context.report({
+      messageId: 'hardCodedColor',
+      node: node,
+      suggest: getTokenSuggestion(node, "".concat(node.callee.name, "()"), config)
+    });
+    return;
+  }
+
+  // Template literals are already handled by 'TemplateLiteral > Identifier' in the main file
+  if (node.type === 'TemplateLiteral') {
+    return;
+  }
+  var identifierNode = null;
+
+  // ObjectExpression > Property > MemberExpression
+  if (node.type === 'MemberExpression') {
+    if (node.property.type !== 'Identifier') {
+      context.report({
+        messageId: 'hardCodedColor',
+        node: node,
+        suggest: getTokenSuggestion(node, generate(node).toString(), config)
+      });
+      return;
+    }
+    identifierNode = node.property;
+  }
+  if (node.type === 'Identifier') {
+    // identifier is the key and not the value
+    if (node.name === propertyKey) {
+      return;
+    }
+    identifierNode = node;
+  }
+
+  // ObjectExpression > Property > MemberExpression > Identifier
+  // ObjectExpression > Property > Identifier
+  if (((_identifierNode = identifierNode) === null || _identifierNode === void 0 ? void 0 : _identifierNode.type) === 'Identifier') {
+    if ((isHardCodedColor(identifierNode.name) || includesHardCodedColor(identifierNode.name) || isLegacyColor(identifierNode.name)) && !isException(identifierNode)) {
+      context.report({
+        messageId: 'hardCodedColor',
+        node: identifierNode,
+        suggest: getTokenSuggestion(identifierNode, identifierNode.name, config)
+      });
+      return;
+    }
+  }
+  return;
+};

package/dist/esm/rules/ensure-design-token-usage/lint-template-identifier-for-color.js

@@ -0,0 +1,47 @@
+import { getIsException } from '../utils/get-is-exception';
+import { isChildOfType } from '../utils/is-child-of-type';
+import { isDecendantOfGlobalToken } from '../utils/is-decendant-of-global-token';
+import { isDecendantOfStyleBlock } from '../utils/is-decendant-of-style-block';
+import { isLegacyElevation } from '../utils/is-elevation';
+import { isLegacyColor } from '../utils/is-legacy-color';
+import { isLegacyNamedColor } from '../utils/is-legacy-named-color';
+import { getElevationTokenExample } from './get-elevation-token-example';
+import { getTokenSuggestion } from './get-token-suggestion';
+var getNodeColumn = function getNodeColumn(node) {
+  return node.loc ? node.loc.start.column : 0;
+};
+
+// TemplateLiteral > Identifier
+export var lintTemplateIdentifierForColor = function lintTemplateIdentifierForColor(node, context, config) {
+  if (node.type !== 'Identifier') {
+    return;
+  }
+  if (isDecendantOfGlobalToken(node) || !isDecendantOfStyleBlock(node)) {
+    return;
+  }
+  var elevation = isLegacyElevation(node.name);
+  if (elevation) {
+    context.report({
+      messageId: 'legacyElevation',
+      node: node,
+      data: {
+        example: getElevationTokenExample(elevation)
+      },
+      fix: function fix(fixer) {
+        if (isChildOfType(node, 'TemplateLiteral') && node.range) {
+          return fixer.replaceTextRange([node.range[0] - 2, node.range[1] + 1], "background-color: ${token('".concat(elevation.background, "')};\n").concat(' '.repeat(getNodeColumn(node) - 2), "box-shadow: ${token('").concat(elevation.shadow, "')}"));
+        }
+        return null;
+      }
+    });
+  }
+  var isException = getIsException(config.exceptions);
+  if (isLegacyColor(node.name) || isLegacyNamedColor(node.name) && !isException(node)) {
+    context.report({
+      messageId: 'hardCodedColor',
+      node: node,
+      suggest: getTokenSuggestion(node, node.name, config)
+    });
+    return;
+  }
+};

package/dist/esm/rules/ensure-design-token-usage/process-css-node.js

@@ -0,0 +1,33 @@
+import { cleanComments } from './clean-comments';
+import { getRawExpression } from './get-raw-expression';
+import { getValue } from './get-value';
+import { splitCssProperties } from './split-css-properties';
+/**
+ * Returns an array of tuples representing a processed css within `TaggedTemplateExpression` node.
+ * 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.
+ * @example
+ * ```
+ * `[['padding: 8', 'padding: ${gridSize()}'], ['margin: 6', 'margin: 6px' ]]`
+ * ```
+ */
+export function processCssNode(node, context) {
+  var combinedString = node.quasi.quasis.map(function (q, i) {
+    return "".concat(q.value.raw).concat(node.quasi.expressions[i] ? getValue(node.quasi.expressions[i], context) : '');
+  }).join('');
+  var rawString = node.quasi.quasis.map(function (q, i) {
+    return "".concat(q.value.raw).concat(node.quasi.expressions[i] ? getRawExpression(node.quasi.expressions[i], context) ? "${".concat(getRawExpression(node.quasi.expressions[i], context), "}") : null : '');
+  }).join('');
+  var cssProperties = splitCssProperties(cleanComments(combinedString));
+  var unalteredCssProperties = splitCssProperties(cleanComments(rawString));
+  if (cssProperties.length !== unalteredCssProperties.length) {
+    // this means something went wrong with the parsing, the original lines can't be reconciled with the processed lines
+    return undefined;
+  }
+  return cssProperties.map(function (cssProperty, index) {
+    return [cssProperty, unalteredCssProperties[index]];
+  });
+}

package/dist/esm/rules/ensure-design-token-usage/remove-pixel-suffix.js

@@ -0,0 +1,8 @@
+import { isCalc } from './is-calc';
+var percentageOrEmOrAuto = /(%$)|(\d+em$)|(auto$)/;
+export var removePixelSuffix = function removePixelSuffix(value) {
+  if (typeof value === 'string' && (percentageOrEmOrAuto.test(value) || isCalc(value))) {
+    return value;
+  }
+  return Number(typeof value === 'string' ? value.replace('px', '') : value);
+};

package/dist/esm/rules/ensure-design-token-usage/spacing.js

@@ -3,12 +3,18 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { isNodeOfType, property } from 'eslint-codemod-utils';
+import { emToPixels } from './em-to-pixels';
+import { findTokenNameByPropertyValue } from './find-token-name-by-property-value';
 import { getRawExpression } from './get-raw-expression';
+import { getTokenNodeForValue } from './get-token-node-for-value';
+import { getTokenReplacement } from './get-token-replacement';
+import { getValue } from './get-value';
 import { insertTokensImport } from './insert-tokens-import';
 import { isAuto } from './is-auto';
+import { isCalc } from './is-calc';
+import { isValidSpacingValue } from './is-valid-spacing-value';
 import { isZero } from './is-zero';
 import { splitShorthandValues } from './split-shorthand-values';
-import { emToPixels, findTokenNameByPropertyValue, getTokenNodeForValue, getTokenReplacement, getValue, isCalc, isValidSpacingValue } from './utils';
 export var lintObjectForSpacing = function lintObjectForSpacing(node, context, ruleConfig, fontSize, tokenNode) {
   if (isNodeOfType(node.value, 'Literal') && !isValidSpacingValue(node.value.value, fontSize)) {
     context.report({

package/dist/esm/rules/ensure-design-token-usage-preview/index.js

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import ruleMeta from '../ensure-design-token-usage/rule-meta';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var rule = createLintRule({
   meta: _objectSpread(_objectSpread({}, ruleMeta), {}, {
     name: 'ensure-design-token-usage/preview',

package/dist/esm/rules/ensure-icon-color/index.js

@@ -1,6 +1,6 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { createIsFromImportSourceFor } from '../../common/is-from-import-source';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
 
 /**

package/dist/esm/rules/ensure-proper-xcss-usage/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';
 import { errorBoundary } from '../utils/error-boundary';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/icon-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';
 import { findProp } from '../utils/find-prop';
 var elements = ['AkButton', 'AKButton', 'Button', 'IconButton', 'MenuItem', 'ButtonItem', 'CustomItem', 'CustomThemeButton', 'LoadingButton', 'BreadcrumbsItem'];
 var elementsIconProps = ['iconBefore', 'iconAfter', 'icon'];

package/dist/esm/rules/lozenge-badge-tag-labelling-system-migration/index.js

@@ -2,7 +2,7 @@ import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 import { isNodeOfType } from 'eslint-codemod-utils';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var rule = createLintRule({
   meta: {
     name: 'lozenge-badge-tag-labelling-system-migration',

package/dist/esm/rules/no-banned-imports/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';
 import { restrictedPaths } from './paths';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/no-boolean-autofocus-on-modal-dialog/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';
 var PROP_NAME = 'autoFocus';
 
 // Lint rule message

package/dist/esm/rules/no-css-tagged-template-expression/index.js

@@ -1,6 +1,7 @@
 import { isCss } from '@atlaskit/eslint-utils/is-supported-import';
-import { createNoTaggedTemplateExpressionRule, noTaggedTemplateExpressionRuleSchema } from '../utils/create-no-tagged-template-expression-rule';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
+import { createNoTaggedTemplateExpressionRule } from '../utils/create-no-tagged-template-expression-rule/create-no-tagged-template-expression-rule';
+import { noTaggedTemplateExpressionRuleSchema } from '../utils/create-no-tagged-template-expression-rule/no-tagged-template-expression-rule-schema';
 var rule = createLintRule({
   meta: {
     name: 'no-css-tagged-template-expression',

package/dist/esm/rules/no-dark-theme-vr-tests/index.js

@@ -1,5 +1,5 @@
 import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var rule = createLintRule({
   meta: {
     name: 'no-dark-theme-vr-tests',

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

@@ -1,8 +1,8 @@
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getSourceCode } from '@atlaskit/eslint-utils/context-compat';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { getConfig } from '../utils/get-deprecated-config';
-import { isDeprecatedJSXAttributeConfig } from '../utils/types';
+import { isDeprecatedJSXAttributeConfig } from '../utils/is-deprecated-jsx-attribute-config';
 export var noDeprecatedJSXAttributeMessageId = 'noDeprecatedJSXAttributes';
 var isImportDeclaration = function isImportDeclaration(programStatement) {
   return (programStatement === null || programStatement === void 0 ? void 0 : programStatement.type) === 'ImportDeclaration';

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

@@ -1,6 +1,6 @@
 import renameMapping from '@atlaskit/tokens/rename-mapping';
 import { getTokenId } from '@atlaskit/tokens/token-ids';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var rule = createLintRule({
   meta: {
     name: 'no-deprecated-design-token-usage',

package/dist/esm/rules/no-deprecated-imports/checks.js

@@ -3,7 +3,7 @@ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r)
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 import { isNodeOfType } from 'eslint-codemod-utils';
 import { getConfig } from '../utils/get-deprecated-config';
-import { isDeprecatedImportConfig } from '../utils/types';
+import { isDeprecatedImportConfig } from '../utils/is-deprecated-import-config';
 import { importNameWithCustomMessageId, pathWithCustomMessageId } from './constants';
 import { getDeprecationIconHandler } from './handlers/icon';
 export var createChecks = function createChecks(context) {

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

@@ -25,7 +25,7 @@
  * THE SOFTWARE.
  */
 
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { errorBoundary } from '../utils/error-boundary';
 import { createChecks } from './checks';
 export var name = 'no-deprecated-imports';