@atlaskit/eslint-plugin-design-system 8.23.0 → 8.23.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/eslint-plugin-design-system
 
+## 8.23.2
+
+### Patch Changes
+
+- [#65758](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/65758) [`16e6a0fbe125`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/16e6a0fbe125) - Internal refactor of `use-primitves` rule. There should be no change to consumers of the rule.
+
+## 8.23.1
+
+### Patch Changes
+
+- [#68093](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/68093) [`4c5371a76547`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/4c5371a76547) - Wrap ensure-design-token-usage with an error boudary to stop it breaking issue-automat CI.
+
 ## 8.23.0
 
 ### Minor Changes

package/dist/cjs/ast-nodes/function-call.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FunctionCall = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+var FunctionCall = exports.FunctionCall = {
+  getName: function getName(node) {
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'CallExpression')) {
+      return undefined;
+    }
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node.callee, 'Identifier')) {
+      return undefined;
+    }
+    return node.callee.name;
+  },
+  updateName: function updateName(node, newName, fixer) {
+    return fixer.replaceText(node.callee, newName);
+  },
+  /**
+   * Function arguments can be many things:
+   * `css(myStyles, () => {}, undefined, 'literal', ...rest) // etc`
+   * They all need slightly different treatment.
+   *
+   * Currently 'getArgumentAtPos' only implements strategies for Literals and ObjectExpressions.
+   * If you need to support another type of arg, add it, and update the type.
+   */
+  getArgumentAtPos: function getArgumentAtPos(node, pos) {
+    var argument = node.arguments[pos];
+    if ((0, _eslintCodemodUtils.isNodeOfType)(argument, 'Literal') && argument.value) {
+      var _argument$value;
+      return {
+        type: 'Literal',
+        value: (_argument$value = argument.value) === null || _argument$value === void 0 ? void 0 : _argument$value.toString()
+      };
+    }
+    if ((0, _eslintCodemodUtils.isNodeOfType)(argument, 'ObjectExpression')) {
+      argument;
+      return {
+        type: 'ObjectExpression',
+        value: argument
+      };
+    }
+  }
+};

package/dist/cjs/ast-nodes/import.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Import = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+var Import = exports.Import = {
+  /**
+   * Note: fixes can't overlap, which means this will fail:
+   * ```
+   * const importNode = Root.findImportByModule('@atlaskit/primitives')
+   * Import.insertNamedSpecifier(importNode, 'Box')
+   * Import.insertNamedSpecifier(importNode, 'xcss')
+   * ```
+   *
+   * For this reason `insertNamedSpecifiers` accepts a `specifiers` array, so you can group all inserts together.
+   */
+  insertNamedSpecifiers: function insertNamedSpecifiers(node, specifiers, fixer) {
+    var _this = this;
+    /**
+     * `insertImportSpecifier()` has the unfortunate implementation detail of naively adding duplicate specifiers.
+     * e.g. calling
+     *  `insertImportSpecifier(importDecl, 'xcss')`
+     * on
+     * `import { Inline, xcss } from '@atlaskit/primitives'`
+     * will result in:
+     * `import { Inline, xcss, xcss } from '@atlaskit/primitives'`.
+     * So, we need to filter out specifiers that are already imported.
+     */
+    var uniqueSpecifiers = specifiers.filter(function (specifier) {
+      return !_this.containsNamedSpecifier(node, specifier);
+    });
+    if (uniqueSpecifiers.length === 0) {
+      return;
+    }
+    return fixer.replaceText(node, "".concat((0, _eslintCodemodUtils.insertImportSpecifier)(node, uniqueSpecifiers.join(', ')), ";\n"));
+  },
+  containsNamedSpecifier: function containsNamedSpecifier(node, name) {
+    return node.specifiers.some(function (specifier) {
+      if (!(0, _eslintCodemodUtils.isNodeOfType)(specifier, 'ImportSpecifier')) {
+        return false;
+      }
+      return specifier.imported.name === name;
+    });
+  }
+};

package/dist/cjs/ast-nodes/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "FunctionCall", {
+  enumerable: true,
+  get: function get() {
+    return _functionCall.FunctionCall;
+  }
+});
+Object.defineProperty(exports, "Import", {
+  enumerable: true,
+  get: function get() {
+    return _import.Import;
+  }
+});
+Object.defineProperty(exports, "JSXAttribute", {
+  enumerable: true,
+  get: function get() {
+    return _jsxAttribute.JSXAttribute;
+  }
+});
+Object.defineProperty(exports, "JSXElement", {
+  enumerable: true,
+  get: function get() {
+    return _jsxElement.JSXElement;
+  }
+});
+Object.defineProperty(exports, "Root", {
+  enumerable: true,
+  get: function get() {
+    return _root.Root;
+  }
+});
+var _functionCall = require("./function-call");
+var _import = require("./import");
+var _jsxAttribute = require("./jsx-attribute");
+var _jsxElement = require("./jsx-element");
+var _root = require("./root");

package/dist/cjs/ast-nodes/jsx-attribute.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSXAttribute = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var HelperJSXAttribute = exports.JSXAttribute = {
+  getName: function getName(node) {
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXAttribute')) {
+      throw new Error('Not a JSXAttribute');
+    }
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node.name, 'JSXIdentifier')) {
+      throw new Error('name is not a JSXIdentifier');
+    }
+    return node.name.name;
+  },
+  updateName: function updateName(node, name, fixer) {
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXAttribute')) {
+      throw new Error('Not a JSXAttribute');
+    }
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node.name, 'JSXIdentifier')) {
+      throw new Error('name is not a JSXIdentifier');
+    }
+    return fixer.replaceText(node.name, (0, _eslintCodemodUtils.literal)(name).toString());
+  },
+  /**
+   * A JSXAttribute value can be many things:
+   * - css='myStyles'
+   * - css={myStyles}
+   * - css={[styles1, styles2]}
+   * - header={<></>}
+   * - css={styleMap.header}
+   * - css={...styles}
+   *
+   * Currently, `getValue` has only implemented strategies for when the value is a string, or an ExpressionStatement
+   * If you need additional functionality add it, and set the correct `type` on the returned object
+   */
+  getValue: function getValue(node) {
+    if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'JSXAttribute')) {
+      return;
+    }
+    if (!node.value) {
+      return;
+    }
+
+    // handle `css={myStyles}`
+    if ((0, _eslintCodemodUtils.isNodeOfType)(node.value, 'JSXExpressionContainer') && (0, _eslintCodemodUtils.isNodeOfType)(node.value.expression, 'Identifier')) {
+      return {
+        type: 'ExpressionStatement',
+        value: node.value.expression.name
+      };
+    }
+
+    // handle `css='myStyles'`
+    if ((0, _eslintCodemodUtils.isNodeOfType)(node.value, 'Literal') && node.value.value) {
+      var _node$value$value;
+      return {
+        type: 'Literal',
+        value: (_node$value$value = node.value.value) === null || _node$value$value === void 0 ? void 0 : _node$value$value.toString()
+      };
+    }
+  }
+};

package/dist/cjs/ast-nodes/jsx-element.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JSXElementHelper = exports.JSXElement = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+var JSXElementHelper = exports.JSXElement = exports.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 (!(0, _eslintCodemodUtils.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, (0, _eslintCodemodUtils.jsxIdentifier)(newName).toString());
+    if (isSelfClosing || !node.closingElement) {
+      return [openingElementFix];
+    }
+    var closingElementFix = fixer.replaceText(node.closingElement.name, (0, _eslintCodemodUtils.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 (!(0, _eslintCodemodUtils.isNodeOfType)(attr, 'JSXAttribute')) {
+        return false;
+      }
+      return attr.name.name === name;
+    });
+  },
+  containsSpreadAttributes: function containsSpreadAttributes(node) {
+    return node.openingElement.attributes.some(function (attr) {
+      return (0, _eslintCodemodUtils.isNodeOfType)(attr, 'JSXSpreadAttribute');
+    });
+  }
+};

package/dist/cjs/ast-nodes/root.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Root = void 0;
+var _eslintCodemodUtils = require("eslint-codemod-utils");
+/* eslint-disable @repo/internal/react/require-jsdoc */
+
+// Little bit unreadable, but better than duplicating the type
+
+var Root = exports.Root = {
+  /**
+   * Note: This can return multiple ImportDeclarations for cases like:
+   * ```
+   * import { Stack } from '@atlaskit/primitives'
+   * import type { StackProps } from '@atlaskit/primitives'
+   * ```
+   */
+  findImportsByModule: function findImportsByModule(root, name) {
+    return root.filter(function (node) {
+      if (!(0, _eslintCodemodUtils.isNodeOfType)(node, 'ImportDeclaration')) {
+        return false;
+      }
+      if (!(0, _eslintCodemodUtils.hasImportDeclaration)(node, name)) {
+        return false;
+      }
+      return true;
+    });
+  },
+  insertImport: function insertImport(root, data, fixer) {
+    return fixer.insertTextBefore(root[0], "".concat((0, _eslintCodemodUtils.insertImportDeclaration)(data.module, data.specifiers), ";\n"));
+  }
+};

package/dist/cjs/rules/ensure-design-token-usage/error-boundary.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorBoundary = void 0;
+/**
+ * ESLint rules should NEVER throw exceptions, because that breaks the VSCode ESLint server
+ * (and probably the IntelliJ one too), which causes linting to fail in a file.
+ *
+ * It also breaks CI, which was the reason this error boundary was added. It's a final
+ * catch all.
+ */
+var errorBoundary = exports.errorBoundary = function errorBoundary(func, _ref) {
+  var config = _ref.config;
+  try {
+    func();
+  } catch (err) {
+    if (!config.failSilently) {
+      // eslint-disable-next-line no-console
+      console.warn(err);
+    }
+  }
+};