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

package/dist/es2019/rules/utils/is-color-css-property-name.js

@@ -0,0 +1,3 @@
+const validColorPropertyNames = new Set(['color', 'background', 'background-color', 'border', 'border-left', 'border-right', 'border-top', 'border-bottom', 'border-color', 'border-left-color', 'border-right-color', 'border-top-color', 'border-bottom-color', 'outline', 'outline-color', 'box-shadow']);
+const kebabize = str => str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());
+export const isColorCssPropertyName = value => validColorPropertyNames.has(kebabize(value));

package/dist/es2019/rules/utils/is-css-in-js-call-node.js

@@ -0,0 +1,2 @@
+const cssInJsCallees = ['css', 'styled', 'styled2'];
+export const isCssInJsCallNode = node => (node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' && node.callee.type === 'Identifier' && cssInJsCallees.includes(node.callee.name);

package/dist/es2019/rules/utils/is-css-in-js-object-node.js

@@ -0,0 +1,2 @@
+const cssInJsCallees = ['css', 'styled', 'styled2'];
+export const isCssInJsObjectNode = node => (node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' && node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && cssInJsCallees.includes(node.callee.object.name);

package/dist/es2019/rules/utils/is-decendant-of-style-block.js

@@ -0,0 +1,38 @@
+import { isCssInJsCallNode } from './is-css-in-js-call-node';
+import { isCssInJsObjectNode } from './is-css-in-js-object-node';
+import { isCssInJsTemplateNode } from './is-css-in-js-template-node';
+export const isDecendantOfStyleBlock = node => {
+  if (node.type === 'VariableDeclarator') {
+    if (node.id.type !== 'Identifier') {
+      return false;
+    }
+    if (
+    // @ts-ignore typeAnnotation is not defined by types
+    node.id.typeAnnotation &&
+    // @ts-ignore typeAnnotation is not defined by types
+    node.id.typeAnnotation.typeAnnotation.type === 'GenericTypeAnnotation' &&
+    // @ts-ignore typeAnnotation is not defined by types
+    node.id.typeAnnotation.typeAnnotation.id.type === 'Identifier') {
+      // @ts-ignore typeAnnotation is not defined by types
+      const typeName = node.id.typeAnnotation.typeAnnotation.id.name;
+      const hasCSSType = ['CSSProperties', 'CSSObject'].some(el => typeName.includes(el));
+      if (hasCSSType) {
+        return true;
+      }
+    }
+
+    // @ts-ignore Name is not defined in types
+    const varName = node.id.name.toLowerCase();
+    return ['style', 'css', 'theme'].some(el => varName.includes(el));
+  }
+  if (isCssInJsCallNode(node) || isCssInJsObjectNode(node) || isCssInJsTemplateNode(node)) {
+    return true;
+  }
+  if (node.type === 'TaggedTemplateExpression' && node.tag.type === 'Identifier' && node.tag.name === 'css') {
+    return true;
+  }
+  if (node.parent) {
+    return isDecendantOfStyleBlock(node.parent);
+  }
+  return false;
+};

package/dist/es2019/rules/utils/is-deprecated-import-config.js

@@ -0,0 +1,3 @@
+export const isDeprecatedImportConfig = config => {
+  return Object.values(config)[0].message !== undefined || Object.values(config)[0].importSpecifiers !== undefined;
+};

package/dist/es2019/rules/utils/is-deprecated-jsx-attribute-config.js

@@ -0,0 +1,3 @@
+export const isDeprecatedJSXAttributeConfig = config => {
+  return Array.isArray(Object.values(config)[0]);
+};

package/dist/es2019/rules/utils/is-hard-coded-color.js

@@ -0,0 +1,19 @@
+import { namedColors } from './named-colors';
+const includesWholeWord = (value, options) => {
+  const values = value.replace(/[^a-zA-Z ]/g, ' ').trim().split(/(?:,|\.| )+/);
+  return values.some(value => options.has(value));
+};
+export const isHardCodedColor = value => {
+  if (includesWholeWord(value.toLowerCase(), namedColors)) {
+    return true;
+  }
+  if (value.startsWith('rgb(') || value.startsWith('rgba(') || value.startsWith('hsl(') || value.startsWith('hsla(') || value.startsWith('lch(') || value.startsWith('lab(') || value.startsWith('color(')) {
+    return true;
+  }
+  if (value.startsWith('#') && (
+  // short hex, hex, or hex with alpha
+  value.length === 4 || value.length === 7 || value.length === 9)) {
+    return true;
+  }
+  return false;
+};

package/dist/es2019/rules/utils/is-legacy-color.js

@@ -0,0 +1,4 @@
+const legacyColors = new Set(['R50', 'R75', 'R100', 'R200', 'R300', 'R400', 'R500', 'Y50', 'Y75', 'Y100', 'Y200', 'Y300', 'Y400', 'Y500', 'G50', 'G75', 'G100', 'G200', 'G300', 'G400', 'G500', 'B50', 'B75', 'B100', 'B200', 'B300', 'B400', 'B500', 'P50', 'P75', 'P100', 'P200', 'P300', 'P400', 'P500', 'T50', 'T75', 'T100', 'T200', 'T300', 'T400', 'T500', 'N0', 'N10', 'N20', 'N30', 'N40', 'N50', 'N60', 'N70', 'N80', 'N90', 'N100', 'N200', 'N300', 'N400', 'N500', 'N600', 'N700', 'N800', 'N900', 'N10A', 'N20A', 'N30A', 'N40A', 'N50A', 'N60A', 'N70A', 'N80A', 'N90A', 'N100A', 'N200A', 'N300A', 'N400A', 'N500A', 'N600A', 'N700A', 'N800A', 'DN900', 'DN800', 'DN700', 'DN600', 'DN500', 'DN400', 'DN300', 'DN200', 'DN100', 'DN90', 'DN80', 'DN70', 'DN60', 'DN50', 'DN40', 'DN30', 'DN20', 'DN10', 'DN0', 'DN800A', 'DN700A', 'DN600A', 'DN500A', 'DN400A', 'DN300A', 'DN200A', 'DN100A', 'DN90A', 'DN80A', 'DN70A', 'DN60A', 'DN50A', 'DN40A', 'DN30A', 'DN20A', 'DN10A',
+// Legacy Trello colors:
+'AtlassianBlue50', 'AtlassianBlue200', 'AtlassianBlue300', 'AtlassianBlue400', 'TrelloBlue25', 'TrelloBlue50', 'TrelloBlue100', 'TrelloBlue200', 'TrelloBlue300', 'TrelloBlue400', 'TrelloBlue500', 'TrelloBlue600', 'TrelloBlue700', 'TrelloBlue800', 'TrelloBlue900', 'Green50', 'Green100', 'Green200', 'Green300', 'Green400', 'Green500', 'Green600', 'Green700', 'Green800', 'Green900', 'Orange50', 'Orange100', 'Orange200', 'Orange300', 'Orange400', 'Orange500', 'Orange600', 'Orange700', 'Orange800', 'Orange900', 'Red50', 'Red100', 'Red200', 'Red300', 'Red400', 'Red500', 'Red600', 'Red700', 'Red800', 'Red900', 'Yellow50', 'Yellow100', 'Yellow200', 'Yellow300', 'Yellow400', 'Yellow500', 'Yellow600', 'Yellow700', 'Yellow800', 'Yellow900', 'Purple50', 'Purple100', 'Purple200', 'Purple300', 'Purple400', 'Purple500', 'Purple600', 'Purple700', 'Purple800', 'Purple900', 'VioletMbgAlert', 'Pink50', 'Pink100', 'Pink200', 'Pink300', 'Pink400', 'Pink500', 'Pink600', 'Pink700', 'Pink800', 'Pink900', 'Sky25', 'Sky50', 'Sky100', 'Sky200', 'Sky300', 'Sky400', 'Sky500', 'Sky600', 'Sky700', 'Sky800', 'Sky900', 'Lime50', 'Lime100', 'Lime200', 'Lime300', 'Lime400', 'Lime500', 'Lime600', 'Lime700', 'Lime800', 'Lime900', 'BusinessBlue50', 'BusinessBlue100', 'BusinessBlue200', 'BusinessBlue300', 'BusinessBlue400', 'BusinessBlue500', 'BusinessBlue600', 'BusinessBlue700', 'BusinessBlue800', 'BusinessBlue900', 'Opacity1', 'Opacity2', 'Opacity3', 'Opacity4', 'Opacity5', 'Opacity6', 'Opacity7', 'Opacity8', 'Opacity9', 'OpacityDark1', 'OpacityDark2', 'OpacityDark3', 'OpacityDark4', 'OpacityDark5', 'OpacityDark6', 'OpacityDark7', 'OpacityDark8', 'OpacityDark9', 'Black']);
+export const isLegacyColor = value => legacyColors.has(value);

package/dist/es2019/rules/utils/is-legacy-named-color.js

@@ -0,0 +1,2 @@
+const legacyColorMixins = new Set(['background', 'backgroundActive', 'backgroundHover', 'backgroundOnLayer', 'text', 'textHover', 'textActive', 'subtleText', 'placeholderText', 'heading', 'subtleHeading', 'codeBlock', 'link', 'linkHover', 'linkActive', 'linkOutline', 'primary', 'blue', 'teal', 'purple', 'red', 'yellow', 'green', 'skeleton']);
+export const isLegacyNamedColor = value => legacyColorMixins.has(value);

package/dist/es2019/rules/utils/named-colors.js

@@ -0,0 +1 @@
+export const namedColors = new Set(['black', 'silver', 'gray', 'white', 'maroon', 'red', 'purple', 'fuchsia', 'green', 'lime', 'olive', 'yellow', 'navy', 'blue', 'teal', 'aqua', 'orange', 'aliceblue', 'antiquewhite', 'aquamarine', 'azure', 'beige', 'bisque', 'blanchedalmond', 'blueviolet', 'brown', 'burlywood', 'cadetblue', 'chartreuse', 'chocolate', 'coral', 'cornflowerblue', 'cornsilk', 'crimson', 'cyan', 'darkblue', 'darkcyan', 'darkgoldenrod', 'darkgray', 'darkgreen', 'darkgrey', 'darkkhaki', 'darkmagenta', 'darkolivegreen', 'darkorange', 'darkorchid', 'darkred', 'darksalmon', 'darkseagreen', 'darkslateblue', 'darkslategray', 'darkslategrey', 'darkturquoise', 'darkviolet', 'deeppink', 'deepskyblue', 'dimgray', 'dimgrey', 'dodgerblue', 'firebrick', 'floralwhite', 'forestgreen', 'gainsboro', 'ghostwhite', 'gold', 'goldenrod', 'greenyellow', 'grey', 'honeydew', 'hotpink', 'indianred', 'indigo', 'ivory', 'khaki', 'lavender', 'lavenderblush', 'lawngreen', 'lemonchiffon', 'lightblue', 'lightcoral', 'lightcyan', 'lightgoldenrodyellow', 'lightgray', 'lightgreen', 'lightgrey', 'lightpink', 'lightsalmon', 'lightseagreen', 'lightskyblue', 'lightslategray', 'lightslategrey', 'lightsteelblue', 'lightyellow', 'limegreen', 'linen', 'magenta', 'mediumaquamarine', 'mediumblue', 'mediumorchid', 'mediumpurple', 'mediumseagreen', 'mediumslateblue', 'mediumspringgreen', 'mediumturquoise', 'mediumvioletred', 'midnightblue', 'mintcream', 'mistyrose', 'moccasin', 'navajowhite', 'oldlace', 'olivedrab', 'orangered', 'orchid', 'palegoldenrod', 'palegreen', 'paleturquoise', 'palevioletred', 'papayawhip', 'peachpuff', 'peru', 'pink', 'plum', 'powderblue', 'rosybrown', 'royalblue', 'saddlebrown', 'salmon', 'sandybrown', 'seagreen', 'seashell', 'sienna', 'skyblue', 'slateblue', 'slategray', 'slategrey', 'snow', 'springgreen', 'steelblue', 'tan', 'thistle', 'tomato', 'turquoise', 'violet', 'wheat', 'whitesmoke', 'yellowgreen', 'rebeccapurple']);

package/dist/es2019/rules/utils/types.js

@@ -1,11 +0,0 @@
-export const isDeprecatedImportConfig = config => {
-  return Object.values(config)[0].message !== undefined || Object.values(config)[0].importSpecifiers !== undefined;
-};
-
-// Checks if the value of object is an array, will need to update this method if we add other deprecated types with array values
-export const isDeprecatedJSXAttributeConfig = config => {
-  return Array.isArray(Object.values(config)[0]);
-};
-
-// From ESLint's repo at path `docs/src/extend/custom-processors.md`. Can't be
-// imported I guess

package/dist/esm/ast-nodes/jsx-element-helper.js

@@ -0,0 +1,84 @@
+import { isNodeOfType, jsxIdentifier } from 'eslint-codemod-utils';
+import { JSXAttribute as HelperJSXAttribute } from './jsx-attribute';
+export var JSXElementHelper = {
+  /**
+   * Names of JSXElements can be any of:
+   * `<Component></Component>` - (JSXIdentifier)
+   * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is a namespace (JSXNamespacedName)
+   * `<MyComponents.Component></MyComponents.Component>` - `MyComponents` is an object (JSXMemberExpression)
+   *
+   * getting the name of a JSXMemberExpression is difficult, because object can contain objects, which is recursively defined in the AST.
+   * e.g. Getting the name of `<MyComponents.PresentationLayer.LeftSideBar.Header />` would require `getName` to recursively resolve all parts of the name.
+   * `getName` does not currently have this functionality. Add it if you need it.
+   */
+  getName: function getName(node) {
+    if (!isNodeOfType(node.openingElement.name, 'JSXIdentifier')) {
+      // TODO: We may want to log this
+      return '';
+    }
+    return node.openingElement.name.name;
+  },
+  updateName: function updateName(node, newName, fixer) {
+    var isSelfClosing = JSXElementHelper.isSelfClosing(node);
+    var openingElementFix = fixer.replaceText(node.openingElement.name, jsxIdentifier(newName).toString());
+    if (isSelfClosing || !node.closingElement) {
+      return [openingElementFix];
+    }
+    var closingElementFix = fixer.replaceText(node.closingElement.name, jsxIdentifier(newName).toString());
+    return [openingElementFix, closingElementFix];
+  },
+  isSelfClosing: function isSelfClosing(node) {
+    return node.openingElement.selfClosing;
+  },
+  getAttributes: function getAttributes(node) {
+    return node.openingElement.attributes;
+  },
+  getAttributeByName: function getAttributeByName(node, name) {
+    return node.openingElement.attributes.find(function (attr) {
+      // Ignore anything other than JSXAttribute
+      if (!isNodeOfType(attr, 'JSXAttribute')) {
+        return false;
+      }
+      return attr.name.name === name;
+    });
+  },
+  containsSpreadAttributes: function containsSpreadAttributes(node) {
+    return node.openingElement.attributes.some(function (attr) {
+      return isNodeOfType(attr, 'JSXSpreadAttribute');
+    });
+  },
+  addAttribute: function addAttribute(node, name, value, fixer) {
+    var attributeString = " ".concat(name, "='").concat(value, "'");
+    var isSelfClosing = JSXElementHelper.isSelfClosing(node);
+    var start = node.openingElement.range ? node.openingElement.range[0] : 0;
+    var end = node.openingElement.range ? node.openingElement.range[1] - (isSelfClosing ? 3 : 1) : 0;
+    var range = [start, end];
+    var fix = fixer.insertTextAfterRange(range, attributeString);
+    return fix;
+  },
+  getChildren: function getChildren(node) {
+    var filteredChildren = node.children.filter(function (child) {
+      // Filter out text children with whitespace characters only as JSX removes whitespace used for intendation
+      if (isNodeOfType(child, 'JSXText')) {
+        var whiteSpaceChars = new RegExp('\\s', 'g');
+        return !whiteSpaceChars.test(child.value);
+      }
+      // Filter out empty JSX expressions, for example JSX expression containing comments only, including eslint ignore comments
+      if (isNodeOfType(child, 'JSXExpressionContainer')) {
+        return !isNodeOfType(child.expression, 'JSXEmptyExpression');
+      }
+      return true;
+    });
+    return filteredChildren;
+  },
+  hasAllowedAttrsOnly: function hasAllowedAttrsOnly(node, allowedProps) {
+    var attrs = JSXElementHelper.getAttributes(node);
+    return attrs.every(function (attr) {
+      if (!isNodeOfType(attr, 'JSXAttribute')) {
+        return false;
+      }
+      var name = HelperJSXAttribute.getName(attr);
+      return allowedProps.includes(name);
+    });
+  }
+};

package/dist/esm/common/token-maps.partial.js

@@ -3,11 +3,12 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 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; }
 /**
  * THIS SECTION WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::8d2e42e9308a5216d1de97408fbb692d>>
+ * @codegen <<SignedSource::d35b67b5e07f9d069f3b0cbdb4cf8e77>>
  * @codegenId spacing
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen-token-maps
  * @codegenDependency ../../../tokens/src/artifacts/tokens-raw/atlassian-spacing.tsx <<SignedSource::535518e7add48ef24f526d0904f70060>>
  */
+/* eslint-disable @atlaskit/volt-strict-mode/no-multiple-exports */
 export var positiveSpaceMap = {
   '0px': 'space.0',
   '2px': 'space.025',

package/dist/esm/rules/consistent-css-prop-usage/index.js

@@ -9,7 +9,7 @@ import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
 import { findVariable } from '@atlaskit/eslint-utils/find-variable';
 import { CSS_IN_JS_IMPORTS } from '@atlaskit/eslint-utils/is-supported-import';
 import { Import } from '../../ast-nodes/import';
-import { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 import { getFirstSupportedImport } from '../utils/get-first-supported-import';
 import { getModuleOfIdentifier } from '../utils/get-module-of-identifier';
 var isDOMElementName = function isDOMElementName(elementName) {

package/dist/esm/rules/enforce-inline-styles-in-select/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 { checkStylesObject } from './utils';
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/ensure-avatar-tag-avatar-props/index.js

@@ -2,7 +2,7 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 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 { createLintRule } from '../utils/create-rule';
+import { createLintRule } from '../utils/create-lint-rule';
 var CONTROLLED_PROPS = ['size', 'borderColor', 'appearance'];
 var rule = createLintRule({
   meta: {

package/dist/esm/rules/ensure-design-token-usage/em-to-pixels.js

@@ -0,0 +1,15 @@
+var emRegex = /(.*\d+)em$/;
+var percentageRegex = /(%$)/;
+export var emToPixels = function emToPixels(value, fontSize) {
+  if (typeof value === 'string') {
+    var emMatch = value.match(emRegex);
+    if (emMatch && typeof fontSize === 'number') {
+      return Number(emMatch[1]) * fontSize;
+    } else if (value.match(percentageRegex)) {
+      return value;
+    } else {
+      return null;
+    }
+  }
+  return value;
+};

package/dist/esm/rules/ensure-design-token-usage/find-token-name-by-property-value.js

@@ -0,0 +1,17 @@
+import { spacing as spacingScale } from '@atlaskit/tokens/tokens-raw';
+import { borderWidthValueToToken } from './border-width-value-to-token';
+import { isBorderSizeProperty } from './is-border-size-property';
+import { isShapeProperty } from './is-shape-property';
+import { normaliseValue } from './normalise-value';
+import { radiusValueToToken } from './radius-value-to-token';
+var spacingValueToToken = Object.fromEntries(spacingScale.map(function (token) {
+  return [token.value, token.cleanName];
+}));
+export function findTokenNameByPropertyValue(propertyName, value) {
+  var lookupValue = normaliseValue(propertyName, value);
+  var tokenName = isShapeProperty(propertyName) ? isBorderSizeProperty(propertyName) ? borderWidthValueToToken[lookupValue] : radiusValueToToken[lookupValue] : spacingValueToToken[lookupValue];
+  if (!tokenName) {
+    return undefined;
+  }
+  return tokenName;
+}

package/dist/esm/rules/ensure-design-token-usage/get-domains-for-property.js

@@ -0,0 +1,28 @@
+import { isColorCssPropertyName } from '../utils/is-color-css-property-name';
+import { isCurrentSurfaceCustomPropertyName } from '../utils/is-current-surface-custom-property-name';
+import { isShapeProperty } from './is-shape-property';
+import { isSpacingProperty } from './is-spacing-property';
+/**
+ * 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.
+ * @example
+ * ```
+ * propertyName: padding, targetOptions: ['spacing'] -> returns ['spacing']
+ * propertyName: backgroundColor, targetOptions: ['spacing'] -> returns []
+ * propertyName: backgroundColor, targetOptions: ['color', 'spacing'] -> returns ['color']
+ * ```
+ */
+export function getDomainsForProperty(propertyName, targetOptions) {
+  var domains = [];
+  if ((isColorCssPropertyName(propertyName) || isCurrentSurfaceCustomPropertyName(propertyName)) && targetOptions.includes('color')) {
+    domains.push('color');
+  }
+  if (isSpacingProperty(propertyName) && targetOptions.includes('spacing')) {
+    domains.push('spacing');
+  }
+  if (isShapeProperty(propertyName) && targetOptions.includes('shape')) {
+    domains.push('shape');
+  }
+  return domains;
+}

package/dist/esm/rules/ensure-design-token-usage/get-font-size-value-in-scope.js

@@ -0,0 +1,24 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import { getValueFromShorthand } from './get-value-from-shorthand';
+export function getFontSizeValueInScope(cssProperties) {
+  var fontSizeNode = cssProperties.find(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+      style = _ref2[0];
+    var _style$split = style.split(':'),
+      _style$split2 = _slicedToArray(_style$split, 2),
+      rawProperty = _style$split2[0],
+      value = _style$split2[1];
+    return /font-size/.test(rawProperty) ? value : null;
+  });
+  if (!fontSizeNode) {
+    return undefined;
+  }
+  var _fontSizeNode$0$split = fontSizeNode[0].split(':'),
+    _fontSizeNode$0$split2 = _slicedToArray(_fontSizeNode$0$split, 2),
+    _ = _fontSizeNode$0$split2[0],
+    fontSizeValue = _fontSizeNode$0$split2[1];
+  if (!fontSizeValue) {
+    return undefined;
+  }
+  return getValueFromShorthand(fontSizeValue)[0];
+}

package/dist/esm/rules/ensure-design-token-usage/get-property-node-from-parent.js

@@ -0,0 +1,13 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export function getPropertyNodeFromParent(property, parentNode) {
+  var propertyNode = parentNode.properties.find(function (node) {
+    if (!isNodeOfType(node, 'Property')) {
+      return;
+    }
+    if (!isNodeOfType(node.key, 'Identifier')) {
+      return;
+    }
+    return node.key.name === property;
+  });
+  return propertyNode;
+}

package/dist/esm/rules/ensure-design-token-usage/get-token-node-for-value.js

@@ -0,0 +1,29 @@
+import { callExpression, identifier, literal } from 'eslint-codemod-utils';
+import { findTokenNameByPropertyValue } from './find-token-name-by-property-value';
+
+/**
+ * Returns a token node for a given value including fallbacks.
+ * @param propertyName camelCase CSS property
+ * @param value string representing pixel value, or font family, or number representing font weight
+ * @example
+ * ```
+ * propertyName: padding, value: '8px' => token('space.100', '8px')
+ * propertyName: fontWeight, value: 400 => token('font.weight.regular', '400')
+ * ```
+ */
+export function getTokenNodeForValue(propertyName, value) {
+  var token = findTokenNameByPropertyValue(propertyName, value);
+  var fallbackValue = propertyName === 'fontFamily' ? {
+    value: "".concat(value),
+    raw: "`".concat(value, "`")
+  } : "".concat(value);
+  return callExpression({
+    callee: identifier({
+      name: 'token'
+    }),
+    arguments: [literal({
+      value: "'".concat(token !== null && token !== void 0 ? token : '', "'")
+    }), literal(fallbackValue)],
+    optional: false
+  });
+}

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

@@ -0,0 +1,18 @@
+import { findTokenNameByPropertyValue } from './find-token-name-by-property-value';
+import { getTokenNodeForValue } from './get-token-node-for-value';
+import { normaliseValue } from './normalise-value';
+
+/**
+ * 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'.
+ */
+export function getTokenReplacement(propertyName, value) {
+  var tokenName = findTokenNameByPropertyValue(propertyName, value);
+  if (!tokenName) {
+    return undefined;
+  }
+  var fallbackValue = normaliseValue(propertyName, value);
+  return getTokenNodeForValue(propertyName, fallbackValue);
+}

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

@@ -0,0 +1,21 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { isDecendantOfGlobalToken } from '../utils/is-decendant-of-global-token';
+var filterSuggestion = function filterSuggestion(_ref) {
+  var shouldReturnSuggestion = _ref.shouldReturnSuggestion;
+  return shouldReturnSuggestion;
+};
+export var getTokenSuggestion = function getTokenSuggestion(node, reference, config) {
+  return [{
+    shouldReturnSuggestion: !isDecendantOfGlobalToken(node) && config.shouldEnforceFallbacks === false,
+    desc: "Convert to token",
+    fix: function fix(fixer) {
+      return fixer.replaceText(isNodeOfType(node.parent, 'MemberExpression') ? node.parent : node, isNodeOfType(node.parent, 'JSXAttribute') ? "{token('')}" : "token('')");
+    }
+  }, {
+    shouldReturnSuggestion: !isDecendantOfGlobalToken(node) && config.shouldEnforceFallbacks === true,
+    desc: "Convert to token with fallback",
+    fix: function fix(fixer) {
+      return fixer.replaceText(isNodeOfType(node.parent, 'MemberExpression') ? node.parent : node, isNodeOfType(node.parent, 'JSXAttribute') ? "{token('', ".concat(reference, ")}") : "token('', ".concat(reference, ")"));
+    }
+  }].filter(filterSuggestion);
+};

package/dist/esm/rules/ensure-design-token-usage/get-value-for-property-node.js

@@ -0,0 +1,7 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { getValue } from './get-value';
+export function getValueForPropertyNode(propertyNode, context) {
+  var propertyValueRaw = isNodeOfType(propertyNode, 'Property') ? getValue(propertyNode.value, context) : null;
+  var propertyValue = Array.isArray(propertyValueRaw) ? propertyValueRaw[0] : propertyValueRaw;
+  return propertyValue;
+}

package/dist/esm/rules/ensure-design-token-usage/get-value-from-shorthand.js

@@ -0,0 +1,13 @@
+import { removePixelSuffix } from './remove-pixel-suffix';
+import { splitShorthandValues } from './split-shorthand-values';
+export var getValueFromShorthand = function getValueFromShorthand(str) {
+  var valueString = String(str);
+  var fontFamily = /(Charlie)|(sans-serif$)|(monospace$)/;
+  var fontWeightString = /(regular$)|(medium$)|(semibold$)|(bold$)/;
+  var fontStyleString = /(inherit$)|(normal$)|(italic$)/;
+  if (fontFamily.test(valueString) || fontWeightString.test(valueString) || fontStyleString.test(valueString)) {
+    return [valueString];
+  }
+  // If we want to filter out NaN just add .filter(Boolean)
+  return splitShorthandValues(String(str).trim()).map(removePixelSuffix);
+};

package/dist/esm/rules/ensure-design-token-usage/get-value-from-template-literal-raw.js

@@ -0,0 +1,30 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { getValue } from './get-value';
+
+/**
+ * @example
+ * ```js
+ * `2 ${variable} 0`
+ *
+ * // results in [2, NaN, 0]
+ * ```
+ * ```js
+ * const variable = 4;
+ * `2 ${variable} 0`
+ *
+ * // results in [2, 4, 0]
+ * ```
+ */
+export var getValueFromTemplateLiteralRaw = function getValueFromTemplateLiteralRaw(node, context) {
+  if (!isNodeOfType(node, "TemplateLiteral")) {
+    return null;
+  }
+  var combinedString = node.quasis.map(function (q, i) {
+    return "".concat(q.value.raw).concat(node.expressions[i] ? getValue(node.expressions[i], context) : '');
+  }).join('').trim();
+  var fontFamily = /(sans-serif$)|(monospace$)/;
+  if (fontFamily.test(combinedString)) {
+    return combinedString;
+  }
+  return combinedString.split(' ');
+};

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

@@ -0,0 +1,135 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+import { getScope } from '@atlaskit/eslint-utils/context-compat';
+import { findIdentifierInParentScope } from '../utils/find-in-parent';
+import { getValueFromShorthand } from './get-value-from-shorthand';
+import { getValueFromTemplateLiteralRaw } from './get-value-from-template-literal-raw';
+import { isBorderRadius } from './is-border-radius';
+import { removePixelSuffix } from './remove-pixel-suffix';
+var isGridSize = function isGridSize(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'gridSize' || node.callee.name === 'getGridSize') &&
+  // If there are arguments we know it's a custom gridSize function and cannot be certain what it returns
+  node.arguments.length === 0;
+};
+var isToken = function isToken(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'token';
+};
+var getRawExpressionForToken = function getRawExpressionForToken(node, context) {
+  var args = node.arguments;
+  var call = "${token(".concat(args.map(function (argNode) {
+    if (isNodeOfType(argNode, 'Literal')) {
+      return argNode.raw;
+    }
+    if (isNodeOfType(argNode, 'Identifier')) {
+      return argNode.name;
+    }
+    if (isNodeOfType(argNode, 'MemberExpression')) {
+      return getValue(argNode, context);
+    }
+  }).join(', '), ")}");
+  return call;
+};
+var isFontSize = function isFontSize(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && (node.callee.name === 'fontSize' || node.callee.name === 'getFontSize');
+};
+var isFontSizeSmall = function isFontSizeSmall(node) {
+  return isNodeOfType(node, 'CallExpression') && isNodeOfType(node.callee, 'Identifier') && node.callee.name === 'fontSizeSmall';
+};
+var getValueFromCallExpression = function getValueFromCallExpression(node, context) {
+  if (!isNodeOfType(node, 'CallExpression')) {
+    return null;
+  }
+  if (isGridSize(node)) {
+    return 8;
+  }
+  if (isBorderRadius(node)) {
+    return 3;
+  }
+  if (isFontSize(node)) {
+    return 14;
+  }
+  if (isFontSizeSmall(node)) {
+    return 11;
+  }
+  if (isToken(node)) {
+    return getRawExpressionForToken(node, context);
+  }
+  return null;
+};
+var getValueFromUnaryExpression = function getValueFromUnaryExpression(node, context) {
+  if (!isNodeOfType(node, 'UnaryExpression')) {
+    return null;
+  }
+  var value = getValue(node.argument, context);
+  if (!value) {
+    return null;
+  }
+
+  // eslint-disable-next-line no-eval
+  return eval("".concat(node.operator, "(").concat(value, ")"));
+};
+var getValueFromBinaryExpression = function getValueFromBinaryExpression(node, context) {
+  if (!isNodeOfType(node, 'BinaryExpression')) {
+    return null;
+  }
+  var left = node.left,
+    right = node.right,
+    operator = node.operator;
+  var leftValue = getValue(left, context);
+  var rightValue = getValue(right, context);
+  var final = rightValue && leftValue ?
+  // eslint-disable-next-line no-eval
+  eval("".concat(leftValue).concat(operator).concat(rightValue)) : null;
+  return final;
+};
+var getValueFromIdentifier = function getValueFromIdentifier(node, context) {
+  if (!isNodeOfType(node, 'Identifier')) {
+    return null;
+  }
+  if (node.name === 'gridSize') {
+    return 8;
+  }
+  var scope = getScope(context, node);
+  var variable = findIdentifierInParentScope({
+    scope: scope,
+    identifierName: node.name
+  });
+  if (!variable) {
+    return null;
+  }
+  var definition = variable.defs[0];
+  if (isNodeOfType(definition.node, 'ImportSpecifier') && isNodeOfType(definition.node.parent, 'ImportDeclaration') && definition.node.parent.source.value === '@atlassian/jira-common-styles/src/main.tsx') {
+    return definition.node.imported.type === 'Identifier' && definition.node.imported.name === 'gridSize' ? 8 : null;
+  }
+  if (!isNodeOfType(definition.node, 'VariableDeclarator')) {
+    return null;
+  }
+  if (!definition.node.init) {
+    return null;
+  }
+  return getValue(definition.node.init, context);
+};
+var getValueFromTemplateLiteral = function getValueFromTemplateLiteral(node, context) {
+  var value = getValueFromTemplateLiteralRaw(node, context);
+  return Array.isArray(value) ? value.map(removePixelSuffix) : value;
+};
+export var getValue = function getValue(node, context) {
+  if (isNodeOfType(node, 'Literal')) {
+    return getValueFromShorthand(node.value);
+  }
+  if (isNodeOfType(node, 'BinaryExpression')) {
+    return getValueFromBinaryExpression(node, context);
+  }
+  if (isNodeOfType(node, 'UnaryExpression')) {
+    return getValueFromUnaryExpression(node, context);
+  }
+  if (isNodeOfType(node, 'CallExpression')) {
+    return getValueFromCallExpression(node, context);
+  }
+  if (isNodeOfType(node, 'Identifier')) {
+    return getValueFromIdentifier(node, context);
+  }
+  if (isNodeOfType(node, 'TemplateLiteral')) {
+    return getValueFromTemplateLiteral(node, context);
+  }
+  return null;
+};