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

package/dist/esm/rules/utils/create-no-tagged-template-expression-rule/create-no-tagged-template-expression-rule.js

@@ -0,0 +1,130 @@
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+// Original source from Compiled https://github.com/atlassian-labs/compiled/blob/master/packages/eslint-plugin/src/utils/create-no-tagged-template-expression-rule/index.ts
+
+import esquery from 'esquery';
+import { getScope, getSourceCode } from '@atlaskit/eslint-utils/context-compat';
+import { getImportSources, isEmotion } from '@atlaskit/eslint-utils/is-supported-import';
+import { generate } from './generate';
+import { getTaggedTemplateExpressionOffset } from './get-tagged-template-expression-offset';
+import { toArguments } from './to-arguments';
+var shouldSkipMultilineComments = false;
+function hasNestedSelectorWithMultipleArguments(arg) {
+  if (arg.type === 'literal' || arg.type === 'expression' || arg.type === 'declaration') {
+    return false;
+  }
+  if (arg.type === 'rule' && arg.declarations.length > 1) {
+    return true;
+  }
+  if (arg.type === 'block') {
+    return arg.blocks.some(hasNestedSelectorWithMultipleArguments);
+  }
+  if (arg.type === 'rule') {
+    return arg.declarations.some(hasNestedSelectorWithMultipleArguments);
+  }
+}
+export var createNoTaggedTemplateExpressionRule = function createNoTaggedTemplateExpressionRule(isUsage, messageId) {
+  return function (context) {
+    var importSources = getImportSources(context);
+    return {
+      TaggedTemplateExpression: function TaggedTemplateExpression(node) {
+        var _getScope = getScope(context, node),
+          references = _getScope.references;
+        if (!isUsage(node.tag, references, importSources)) {
+          return;
+        }
+        context.report({
+          messageId: messageId,
+          node: node,
+          fix: /*#__PURE__*/_regeneratorRuntime.mark(function fix(fixer) {
+            var quasi, source, matches, args, oldCode, withoutQuasi, newCode, usesEmotion;
+            return _regeneratorRuntime.wrap(function fix$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  quasi = node.quasi;
+                  source = getSourceCode(context); // TODO Eventually handle comments instead of skipping them
+                  // Skip auto-fixing comments
+                  if (!(shouldSkipMultilineComments && quasi.quasis.map(function (q) {
+                    return q.value.raw;
+                  }).join('').match(/\/\*[\s\S]*\*\//g))) {
+                    _context.next = 4;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 4:
+                  matches = esquery(node, 'ArrowFunctionExpression > BlockStatement');
+                  if (!matches.length) {
+                    _context.next = 7;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 7:
+                  if (!(!quasi.expressions.length && quasi.quasis.length === 1 && !quasi.quasis[0].value.raw.trim())) {
+                    _context.next = 11;
+                    break;
+                  }
+                  _context.next = 10;
+                  return fixer.replaceText(quasi, '({})');
+                case 10:
+                  return _context.abrupt("return");
+                case 11:
+                  args = toArguments(source, quasi);
+                  if (!args.some(hasNestedSelectorWithMultipleArguments)) {
+                    _context.next = 14;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 14:
+                  if (!(args.length < 1)) {
+                    _context.next = 16;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 16:
+                  oldCode = source.getText(node); // Remove quasi:
+                  // styled.div<Props>`
+                  //    color: red;
+                  // `
+                  // becomes
+                  // styled.div<Props>
+                  withoutQuasi = oldCode.replace(source.getText(quasi), '');
+                  newCode = withoutQuasi +
+                  // Indent the arguments after the tagged template expression range
+                  generate(args, getTaggedTemplateExpressionOffset(node));
+                  if (!(oldCode === newCode)) {
+                    _context.next = 21;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 21:
+                  // For styles like `position: initial !important`,
+                  // Emotion can give typechecking errors when using object syntax
+                  // due to csstype being overly strict
+                  usesEmotion = isEmotion(node.tag, references, importSources);
+                  if (!(usesEmotion && !!newCode.match(/!\s*important/gm))) {
+                    _context.next = 24;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 24:
+                  if (!/\$\{.*:/.test(newCode)) {
+                    _context.next = 26;
+                    break;
+                  }
+                  return _context.abrupt("return");
+                case 26:
+                  _context.next = 28;
+                  return fixer.insertTextBefore(node, newCode);
+                case 28:
+                  _context.next = 30;
+                  return fixer.remove(node);
+                case 30:
+                case "end":
+                  return _context.stop();
+              }
+            }, fix);
+          })
+        });
+      }
+    };
+  };
+};

package/dist/esm/rules/utils/create-no-tagged-template-expression-rule/no-tagged-template-expression-rule-schema.js

@@ -0,0 +1,14 @@
+// Original source from Compiled https://github.com/atlassian-labs/compiled/blob/master/packages/eslint-plugin/src/utils/create-no-tagged-template-expression-rule/index.ts
+
+export var noTaggedTemplateExpressionRuleSchema = [{
+  type: 'object',
+  properties: {
+    importSources: {
+      type: 'array',
+      items: {
+        type: 'string'
+      },
+      uniqueItems: true
+    }
+  }
+}];

package/dist/esm/rules/utils/create-rule.js

@@ -1,5 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-import { getCreateLintRule, getPathSafeName } from '@atlaskit/eslint-utils/create-rule';
+import { getRuleUrl } from './get-rule-url';
 
 /**
  * We are moving to our own small abstraction to create a lint rule that we have the power
@@ -13,15 +13,4 @@ import { getCreateLintRule, getPathSafeName } from '@atlaskit/eslint-utils/creat
 var createRule = ESLintUtils.RuleCreator(function (name) {
   return getRuleUrl(name);
 });
-
-/**
- * Tiny wrapped over the ESLint rule module type that ensures
- * there is a docs link to our ESLint plugin documentation page,
- * as well as improving type support.
- */
-export { createRule };
-export var createLintRule = getCreateLintRule(getRuleUrl);
-function getRuleUrl(ruleName) {
-  var name = getPathSafeName(ruleName);
-  return "https://atlassian.design/components/eslint-plugin-design-system/".concat(name, "/usage");
-}
+export { createRule };

package/dist/esm/rules/utils/get-rule-url.js

@@ -0,0 +1,5 @@
+import { getPathSafeName } from '@atlaskit/eslint-utils/create-rule';
+export function getRuleUrl(ruleName) {
+  var name = getPathSafeName(ruleName);
+  return "https://atlassian.design/components/eslint-plugin-design-system/".concat(name, "/usage");
+}

package/dist/esm/rules/utils/includes-hard-coded-color.js

@@ -0,0 +1,17 @@
+import { namedColors } from './named-colors';
+var includesWholeWord = function includesWholeWord(value, options) {
+  var values = value.replace(/[^a-zA-Z ]/g, ' ').trim().split(/(?:,|\.| )+/);
+  return values.some(function (value) {
+    return options.has(value);
+  });
+};
+export var includesHardCodedColor = function includesHardCodedColor(raw) {
+  var value = raw.toLowerCase();
+  if (/#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})\b|((?:rgb|hsl)a?|(lch|lab|color))\([^\)]*\)/.exec(value.toLowerCase())) {
+    return true;
+  }
+  if (includesWholeWord(value, namedColors)) {
+    return true;
+  }
+  return false;
+};

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

@@ -0,0 +1,9 @@
+var 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']);
+var kebabize = function kebabize(str) {
+  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, function ($, ofs) {
+    return (ofs ? '-' : '') + $.toLowerCase();
+  });
+};
+export var isColorCssPropertyName = function isColorCssPropertyName(value) {
+  return validColorPropertyNames.has(kebabize(value));
+};

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

@@ -0,0 +1,4 @@
+var cssInJsCallees = ['css', 'styled', 'styled2'];
+export var isCssInJsCallNode = function isCssInJsCallNode(node) {
+  return (node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' && node.callee.type === 'Identifier' && cssInJsCallees.includes(node.callee.name);
+};

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

@@ -0,0 +1,4 @@
+var cssInJsCallees = ['css', 'styled', 'styled2'];
+export var isCssInJsObjectNode = function isCssInJsObjectNode(node) {
+  return (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/esm/rules/utils/is-decendant-of-style-block.js

@@ -0,0 +1,43 @@
+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';
+var _isDecendantOfStyleBlock = function 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
+      var typeName = node.id.typeAnnotation.typeAnnotation.id.name;
+      var hasCSSType = ['CSSProperties', 'CSSObject'].some(function (el) {
+        return typeName.includes(el);
+      });
+      if (hasCSSType) {
+        return true;
+      }
+    }
+
+    // @ts-ignore Name is not defined in types
+    var varName = node.id.name.toLowerCase();
+    return ['style', 'css', 'theme'].some(function (el) {
+      return 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;
+};
+export { _isDecendantOfStyleBlock as isDecendantOfStyleBlock };

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

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

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

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

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

@@ -0,0 +1,21 @@
+import { namedColors } from './named-colors';
+var includesWholeWord = function includesWholeWord(value, options) {
+  var values = value.replace(/[^a-zA-Z ]/g, ' ').trim().split(/(?:,|\.| )+/);
+  return values.some(function (value) {
+    return options.has(value);
+  });
+};
+export var isHardCodedColor = function 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/esm/rules/utils/is-legacy-color.js

@@ -0,0 +1,6 @@
+var 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 var isLegacyColor = function isLegacyColor(value) {
+  return legacyColors.has(value);
+};

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

@@ -0,0 +1,4 @@
+var 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 var isLegacyNamedColor = function isLegacyNamedColor(value) {
+  return legacyColorMixins.has(value);
+};

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

@@ -0,0 +1 @@
+export var 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/esm/rules/utils/types.js

@@ -1,11 +0,0 @@
-export var isDeprecatedImportConfig = function 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 var isDeprecatedJSXAttributeConfig = function 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/types/ast-nodes/jsx-element-helper.d.ts

@@ -0,0 +1,23 @@
+import type { Rule } from 'eslint';
+import { type JSXAttribute, type JSXElement, type JSXFragment, type JSXSpreadAttribute } from 'eslint-codemod-utils';
+export declare const 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(node: JSXElement): string;
+    updateName(node: JSXElement, newName: string, fixer: Rule.RuleFixer): Rule.Fix[];
+    isSelfClosing(node: JSXElement): boolean;
+    getAttributes(node: JSXElement): (JSXAttribute | JSXSpreadAttribute)[];
+    getAttributeByName(node: JSXElement, name: string): JSXAttribute | undefined;
+    containsSpreadAttributes(node: JSXElement): boolean;
+    addAttribute(node: JSXElement, name: string, value: string, fixer: Rule.RuleFixer): Rule.Fix;
+    getChildren(node: JSXElement | JSXFragment): JSXElement["children"];
+    hasAllowedAttrsOnly(node: JSXElement, allowedProps: string[]): boolean;
+};

package/dist/types/common/token-maps.partial.d.ts

@@ -1,6 +1,6 @@
 /**
  * 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>>

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

@@ -0,0 +1 @@
+export declare const emToPixels: <T extends unknown>(value: T, fontSize: number | null | undefined) => number | T | null;

package/dist/types/rules/ensure-design-token-usage/find-token-name-by-property-value.d.ts

@@ -0,0 +1 @@
+export declare function findTokenNameByPropertyValue(propertyName: string, value: string): string | undefined;

package/dist/types/rules/ensure-design-token-usage/get-domains-for-property.d.ts

@@ -0,0 +1,13 @@
+import type { Domains } from './types';
+/**
+ * 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 declare function getDomainsForProperty(propertyName: string, targetOptions: Domains): Domains;

package/dist/types/rules/ensure-design-token-usage/get-font-size-value-in-scope.d.ts

@@ -0,0 +1,2 @@
+import { type ProcessedCSSLines } from './types';
+export declare function getFontSizeValueInScope(cssProperties: ProcessedCSSLines): number | undefined;

package/dist/types/rules/ensure-design-token-usage/get-property-node-from-parent.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type ObjectExpression, type Property, type SpreadElement } from 'eslint-codemod-utils';
+export declare function getPropertyNodeFromParent(property: string, parentNode: ObjectExpression & Rule.NodeParentExtension): Property | SpreadElement | undefined;

package/dist/types/rules/ensure-design-token-usage/get-token-node-for-value.d.ts

@@ -0,0 +1,12 @@
+import { type SimpleCallExpression, type StringableASTNode } from 'eslint-codemod-utils';
+/**
+ * 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 declare function getTokenNodeForValue(propertyName: string, value: string): StringableASTNode<SimpleCallExpression>;

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

@@ -0,0 +1,8 @@
+import type { SimpleCallExpression, StringableASTNode } from 'eslint-codemod-utils';
+/**
+ * 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 declare function getTokenReplacement(propertyName: string, value: string): StringableASTNode<SimpleCallExpression> | undefined;

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

@@ -0,0 +1,7 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+type Suggestion = {
+    shouldReturnSuggestion: boolean;
+} & Rule.SuggestionReportDescriptor;
+export declare const getTokenSuggestion: (node: Rule.Node, reference: string, config: RuleConfig) => Suggestion[];
+export {};

package/dist/types/rules/ensure-design-token-usage/get-value-for-property-node.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type Property, type SpreadElement } from 'eslint-codemod-utils';
+export declare function getValueForPropertyNode(propertyNode: Property | SpreadElement, context: Rule.RuleContext): string | number | null | undefined;

package/dist/types/rules/ensure-design-token-usage/get-value-from-shorthand.d.ts

@@ -0,0 +1 @@
+export declare const getValueFromShorthand: (str: unknown) => (string | number)[];

package/dist/types/rules/ensure-design-token-usage/get-value-from-template-literal-raw.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import { type EslintNode } from 'eslint-codemod-utils';
+/**
+ * @example
+ * ```js
+ * `2 ${variable} 0`
+ *
+ * // results in [2, NaN, 0]
+ * ```
+ * ```js
+ * const variable = 4;
+ * `2 ${variable} 0`
+ *
+ * // results in [2, 4, 0]
+ * ```
+ */
+export declare const getValueFromTemplateLiteralRaw: (node: EslintNode, context: Rule.RuleContext) => string[] | string | null;

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

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import { type EslintNode } from 'eslint-codemod-utils';
+export declare const getValue: (node: EslintNode, context: Rule.RuleContext) => string | number | (string | number)[] | null | undefined;

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

@@ -1,6 +1,5 @@
 import type { Rule } from 'eslint';
 import type { RuleConfig } from './types';
-declare const createWithConfig: (initialConfig: RuleConfig) => Rule.RuleModule['create'];
+export declare const createWithConfig: (initialConfig: RuleConfig) => Rule.RuleModule['create'];
 declare const rule: Rule.RuleModule;
 export default rule;
-export { createWithConfig };

package/dist/types/rules/ensure-design-token-usage/is-border-size-property.d.ts

@@ -0,0 +1 @@
+export declare function isBorderSizeProperty(propertyName: string): boolean;

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

@@ -0,0 +1 @@
+export declare const isCalc: (value: string | number | boolean | RegExp | null | undefined | any[] | bigint) => boolean;

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

@@ -0,0 +1 @@
+export declare function isRadiusProperty(propertyName: string): boolean;

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

@@ -0,0 +1 @@
+export declare function isShapeProperty(propertyName: string): boolean;

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

@@ -0,0 +1 @@
+export declare const isSpacingProperty: (propertyName: string) => boolean;

package/dist/types/rules/ensure-design-token-usage/is-valid-spacing-value.d.ts

@@ -0,0 +1 @@
+export declare const isValidSpacingValue: (value: string | number | boolean | RegExp | null | undefined | any[] | bigint, fontSize?: number | null | undefined) => boolean;

package/dist/types/rules/ensure-design-token-usage/lint-jsx-identifier-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintJSXIdentifierForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types/rules/ensure-design-token-usage/lint-jsx-literal-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintJSXLiteralForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types/rules/ensure-design-token-usage/lint-jsx-member-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintJSXMemberForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types/rules/ensure-design-token-usage/lint-object-for-color.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+import { type Property } from 'eslint-codemod-utils';
+import type { RuleConfig } from './types';
+export declare const lintObjectForColor: (propertyNode: Property, context: Rule.RuleContext, config: RuleConfig) => void;

package/dist/types/rules/ensure-design-token-usage/lint-template-identifier-for-color.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+import type { RuleConfig } from './types';
+export declare const lintTemplateIdentifierForColor: (node: Rule.Node, context: Rule.RuleContext, config: RuleConfig) => void;

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

@@ -0,0 +1,16 @@
+import type { Rule } from 'eslint';
+import { type TaggedTemplateExpression } from 'eslint-codemod-utils';
+import type { ProcessedCSSLines } from './types';
+/**
+ * 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 declare function processCssNode(node: TaggedTemplateExpression & Rule.NodeParentExtension, context: Rule.RuleContext): ProcessedCSSLines | undefined;

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

@@ -0,0 +1 @@
+export declare const removePixelSuffix: (value: string | number) => string | number;

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

@@ -9,3 +9,4 @@ export type RuleConfig = {
     exceptions?: string[];
     failSilently?: boolean;
 };
+export type ProcessedCSSLines = [string, string][];

package/dist/types/rules/no-deprecated-apis/helpers/validate-deprecated-apis-config.d.ts

@@ -1,2 +1,2 @@
-import type { DeprecatedJSXAttributeConfig } from '../../../../src/rules/utils/types';
+import type { DeprecatedJSXAttributeConfig } from '../../utils/types';
 export declare const getValidatedConfig: (originalDeprecatedConfig: string) => DeprecatedJSXAttributeConfig;

package/dist/types/rules/no-placeholder/affected-atlaskit-packages.d.ts

@@ -0,0 +1 @@
+export declare const AFFECTED_ATLASKIT_PACKAGES: Record<string, string[]>;

package/dist/types/rules/no-placeholder/affected-html-elements.d.ts

@@ -0,0 +1 @@
+export declare const AFFECTED_HTML_ELEMENTS: string[];

package/dist/types/rules/no-placeholder/index.d.ts

@@ -1,6 +1,2 @@
-export declare const AFFECTED_HTML_ELEMENTS: string[];
-export declare const AFFECTED_ATLASKIT_PACKAGES: Record<string, string[]>;
-export declare const ATLASKIT_FORM_PACKAGE = "@atlaskit/form";
-export declare const ATLASKIT_FIELD_IMPORT = "Field";
 declare const rule: import('eslint').Rule.RuleModule;
 export default rule;

package/dist/types/rules/no-readonly-or-disabled-inputs/affected-atlaskit-packages.d.ts

@@ -0,0 +1 @@
+export declare const AFFECTED_ATLASKIT_PACKAGES: Record<string, string[]>;

package/dist/types/rules/no-readonly-or-disabled-inputs/affected-html-elements.d.ts

@@ -0,0 +1 @@
+export declare const AFFECTED_HTML_ELEMENTS: string[];

package/dist/types/rules/no-readonly-or-disabled-inputs/index.d.ts

@@ -1,6 +1,2 @@
-export declare const AFFECTED_HTML_ELEMENTS: string[];
-export declare const AFFECTED_ATLASKIT_PACKAGES: Record<string, string[]>;
-export declare const UNWANTED_HTML_ATTRIBUTES: readonly ["disabled", "readonly"];
-export declare const UNWANTED_ATLASKIT_ATTRIBUTES: readonly ["isDisabled", "isReadOnly"];
 declare const rule: import('eslint').Rule.RuleModule;
 export default rule;

package/dist/types/rules/no-readonly-or-disabled-inputs/unwanted-atlaskit-attributes.d.ts

@@ -0,0 +1 @@
+export declare const UNWANTED_ATLASKIT_ATTRIBUTES: readonly ["isDisabled", "isReadOnly"];

package/dist/types/rules/no-readonly-or-disabled-inputs/unwanted-html-attributes.d.ts

@@ -0,0 +1 @@
+export declare const UNWANTED_HTML_ATTRIBUTES: readonly ["disabled", "readonly"];

package/dist/types/rules/no-unused-css-map/get-css-map-object.d.ts

@@ -0,0 +1,5 @@
+import type { Rule } from 'eslint';
+import type { CallExpression as ESCallExpression, ObjectExpression } from 'estree';
+type CallExpression = ESCallExpression & Rule.NodeParentExtension;
+export declare const getCssMapObject: (node: CallExpression) => ObjectExpression | undefined;
+export {};

package/dist/types/rules/no-unused-css-map/unused-css-map-checker.d.ts

@@ -0,0 +1,14 @@
+import type { Rule } from 'eslint';
+import type { CallExpression as ESCallExpression, ObjectExpression } from 'estree';
+type CallExpression = ESCallExpression & Rule.NodeParentExtension;
+export declare class UnusedCssMapChecker {
+    private readonly cssMapObject;
+    private readonly cssMapCallNode;
+    private readonly report;
+    private readonly context;
+    constructor(cssMapObject: ObjectExpression, context: Rule.RuleContext, cssMapCallNode: CallExpression);
+    private checkForUnusedStyles;
+    private findCssMapVariable;
+    run(): void;
+}
+export {};