@atlaskit/eslint-plugin-design-system 10.8.2 → 10.10.0

package/dist/es2019/rules/utils/error-boundary.js

@@ -1,3 +1,9 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+// Need to intersect type RuleListener with a generic function to allow use of Parameters<...> to be used
+
+// Allow config to be to be easily passed from rules
+
 /**
  * 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.
@@ -5,15 +11,53 @@
  * It also breaks CI, which was the reason this error boundary was added. It's a final
  * catch all.
  */
-export const errorBoundary = (func, {
-  config
-}) => {
-  try {
-    func();
-  } catch (err) {
-    if (!config.failSilently) {
-      // eslint-disable-next-line no-console
-      console.warn(err);
-    }
+export function errorBoundary(ruleOrRules, config = false) {
+  const failSilently = failSilentlyFromConfig(config);
+  if (isSingleRuleListener(ruleOrRules)) {
+    return wrapSingleRuleListener(ruleOrRules, failSilently);
+  }
+  return wrapRuleListener(ruleOrRules, failSilently);
+}
+function isSingleRuleListener(rule) {
+  return typeof rule === 'function';
+}
+function failSilentlyFromConfig(c) {
+  switch (typeof c) {
+    case 'undefined':
+      return false;
+    case 'boolean':
+      return c;
+    case 'object':
+      if ('failSilently' in c) {
+        var _c$failSilently;
+        return (_c$failSilently = c.failSilently) !== null && _c$failSilently !== void 0 ? _c$failSilently : false;
+      } else if ('config' in c) {
+        var _c$config$failSilentl;
+        return (_c$config$failSilentl = c.config.failSilently) !== null && _c$config$failSilentl !== void 0 ? _c$config$failSilentl : false;
+      }
+      return false;
+    default:
+      throw new Error('Invalid config');
   }
-};
+}
+function wrapSingleRuleListener(rule, failSilently) {
+  return (...args) => {
+    try {
+      rule(...args);
+    } catch (err) {
+      if (!failSilently) {
+        // eslint-disable-next-line no-console
+        console.warn(err);
+      }
+    }
+  };
+}
+function wrapRuleListener(ruleListener, failSilently) {
+  return Object.entries(ruleListener).reduce((wrappedRuleListener, e) => {
+    const ruleName = e[0];
+    const rule = e[1];
+    return Object.assign(wrappedRuleListener, {
+      [ruleName]: wrapSingleRuleListener(rule, failSilently)
+    });
+  }, {});
+}

package/dist/esm/presets/all.codegen.js

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::9bb5329713677543f16019954484ae2f>>
+ * @codegen <<SignedSource::ab43b6e1a867d07b9a27eae78d48834a>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 export default {
@@ -12,6 +12,7 @@ export default {
     '@atlaskit/design-system/icon-label': 'warn',
     '@atlaskit/design-system/no-banned-imports': 'error',
     '@atlaskit/design-system/no-css-tagged-template-expression': 'error',
+    '@atlaskit/design-system/no-custom-icons': 'warn',
     '@atlaskit/design-system/no-deprecated-apis': 'error',
     '@atlaskit/design-system/no-deprecated-design-token-usage': 'warn',
     '@atlaskit/design-system/no-deprecated-imports': 'error',

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

@@ -490,7 +490,8 @@ var defaultConfig = {
   cssImportSource: CSS_IN_JS_IMPORTS.compiled,
   xcssImportSource: CSS_IN_JS_IMPORTS.atlaskitPrimitives,
   excludeReactComponents: false,
-  autoFix: true
+  autoFix: true,
+  shouldAlwaysCheckXcss: false
 };
 var rule = createLintRule({
   meta: {
@@ -533,6 +534,9 @@ var rule = createLintRule({
         excludeReactComponents: {
           type: 'boolean'
         },
+        shouldAlwaysCheckXcss: {
+          type: 'boolean'
+        },
         autoFix: {
           type: 'boolean'
         }
@@ -547,7 +551,20 @@ var rule = createLintRule({
         var node = nodeOriginal;
         var name = node.name,
           value = node.value;
-        if (mergedConfig.excludeReactComponents && node.parent.type === 'JSXOpeningElement') {
+
+        /**
+         * We skip linting `xcss` attributes if:
+         *
+         * - excludeReactComponents === true
+         * - shouldAlwaysCheckXcss === false
+         *
+         * In the future we may want to remove `shouldAlwaysCheckXcss`
+         * and just always lint `xcss`, regardless of `excludeReactComponents`
+         */
+        if (mergedConfig.excludeReactComponents && name.name === 'xcss' && !mergedConfig.shouldAlwaysCheckXcss) {
+          return;
+        }
+        if (mergedConfig.excludeReactComponents && node.parent.type === 'JSXOpeningElement' && name.name === 'css') {
           // e.g. <item.before />
           if (node.parent.name.type === 'JSXMemberExpression') {
             return;

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

@@ -29,26 +29,18 @@ var createWithConfig = function createWithConfig(initialConfig) {
       failSilently: (userConfig === null || userConfig === void 0 ? void 0 : userConfig.failSilently) || defaultConfig.failSilently
     };
     var tokenNode = null;
-    return {
+    return errorBoundary({
       ImportDeclaration: function ImportDeclaration(node) {
-        return errorBoundary(function () {
-          if (node.source.value === '@atlaskit/tokens' && config.applyImport) {
-            tokenNode = node;
-          }
-        }, {
-          config: config
-        });
+        if (node.source.value === '@atlaskit/tokens' && config.applyImport) {
+          tokenNode = node;
+        }
       },
       // For expressions within template literals (e.g. `color: ${red}`) - color only
       'TemplateLiteral > Identifier': function TemplateLiteralIdentifier(node) {
-        return errorBoundary(function () {
-          if (config.domains.includes('color')) {
-            return lintTemplateIdentifierForColor(node, context, config);
-          }
-          return;
-        }, {
-          config: config
-        });
+        if (config.domains.includes('color')) {
+          return lintTemplateIdentifierForColor(node, context, config);
+        }
+        return;
       },
       // const styles = css({ color: 'red', margin: '4px' }), styled.div({ color: 'red', margin: '4px' })
       ObjectExpression: function (_ObjectExpression) {
@@ -60,263 +52,243 @@ var createWithConfig = function createWithConfig(initialConfig) {
         };
         return ObjectExpression;
       }(function (parentNode) {
-        return errorBoundary(function () {
-          var _context$getScope = context.getScope(),
-            references = _context$getScope.references;
-          /**
-           * NOTE: This rule doesn't have an `importSources` config option,
-           * so this will just be equal to DEFAULT_IMPORT_SOURCES (which is fine)
-           */
-          var importSources = getImportSources(context);
+        var _context$getScope = context.getScope(),
+          references = _context$getScope.references;
+        /**
+         * NOTE: This rule doesn't have an `importSources` config option,
+         * so this will just be equal to DEFAULT_IMPORT_SOURCES (which is fine)
+         */
+        var importSources = getImportSources(context);
 
-          // To force the correct node type
-          if (!isNodeOfType(parentNode, 'ObjectExpression')) {
-            return;
-          }
+        // To force the correct node type
+        if (!isNodeOfType(parentNode, 'ObjectExpression')) {
+          return;
+        }
 
-          // Return for nested objects - these get handled automatically so without returning we'd be doubling up
-          if (parentNode.parent.type === 'Property') {
+        // Return for nested objects - these get handled automatically so without returning we'd be doubling up
+        if (parentNode.parent.type === 'Property') {
+          return;
+        }
+        if (isDecendantOfXcssBlock(parentNode, references, importSources)) {
+          return;
+        }
+        if (!isDecendantOfStyleBlock(parentNode) && !isDecendantOfType(parentNode, 'JSXExpressionContainer')) {
+          return;
+        }
+        function findObjectStyles(node) {
+          if (!isNodeOfType(node, 'Property')) {
             return;
           }
-          if (isDecendantOfXcssBlock(parentNode, references, importSources)) {
+          if (isNodeOfType(node.value, 'ObjectExpression')) {
+            return node.value.properties.forEach(findObjectStyles);
+          }
+          if (!isNodeOfType(node.key, 'Identifier') && !isNodeOfType(node.key, 'Literal')) {
             return;
           }
-          if (!isDecendantOfStyleBlock(parentNode) && !isDecendantOfType(parentNode, 'JSXExpressionContainer')) {
+          var propertyName = isNodeOfType(node.key, 'Identifier') ? node.key.name : String(node.key.value);
+
+          // Returns which domains to lint against based on rule's config and current property
+          var domains = getDomainsForProperty(propertyName, config.domains);
+          if (domains.length === 0 || isDecendantOfGlobalToken(node.value)) {
             return;
           }
-          function findObjectStyles(node) {
-            if (!isNodeOfType(node, 'Property')) {
-              return;
-            }
-            if (isNodeOfType(node.value, 'ObjectExpression')) {
-              return node.value.properties.forEach(findObjectStyles);
-            }
-            if (!isNodeOfType(node.key, 'Identifier') && !isNodeOfType(node.key, 'Literal')) {
-              return;
+          if (isNodeOfType(node.value, 'TemplateLiteral')) {
+            var value = getValueFromTemplateLiteralRaw(node.value, context);
+            if (Array.isArray(value) && value.some(isCalc)) {
+              return context.report({
+                node: node,
+                messageId: 'noCalcUsage',
+                data: {
+                  payload: "".concat(propertyName)
+                }
+              });
             }
-            var propertyName = isNodeOfType(node.key, 'Identifier') ? node.key.name : String(node.key.value);
-
-            // Returns which domains to lint against based on rule's config and current property
-            var domains = getDomainsForProperty(propertyName, config.domains);
-            if (domains.length === 0 || isDecendantOfGlobalToken(node.value)) {
+            if (node.value.expressions.some(isDecendantOfGlobalToken)) {
               return;
             }
-            if (isNodeOfType(node.value, 'TemplateLiteral')) {
-              var value = getValueFromTemplateLiteralRaw(node.value, context);
-              if (Array.isArray(value) && value.some(isCalc)) {
-                return context.report({
-                  node: node,
-                  messageId: 'noCalcUsage',
-                  data: {
-                    payload: "".concat(propertyName)
-                  }
-                });
-              }
-              if (node.value.expressions.some(isDecendantOfGlobalToken)) {
-                return;
-              }
-            }
-            if (domains.includes('color')) {
-              return lintObjectForColor(node, context, config);
-            }
-            if (domains.includes('spacing') || domains.includes('shape')) {
-              /**
-               * We do this in case the fontSize for a style object is declared alongside the `em` or `lineHeight` declaration.
-               */
-              var fontSizeNode = getPropertyNodeFromParent('fontSize', parentNode);
-              var fontSize = fontSizeNode && getValueForPropertyNode(fontSizeNode, context);
-              return lintObjectForSpacing(node, context, config, fontSize, tokenNode);
-            }
           }
-          parentNode.properties.forEach(findObjectStyles);
-        }, {
-          config: config
-        });
+          if (domains.includes('color')) {
+            return lintObjectForColor(node, context, config);
+          }
+          if (domains.includes('spacing') || domains.includes('shape')) {
+            /**
+             * We do this in case the fontSize for a style object is declared alongside the `em` or `lineHeight` declaration.
+             */
+            var fontSizeNode = getPropertyNodeFromParent('fontSize', parentNode);
+            var fontSize = fontSizeNode && getValueForPropertyNode(fontSizeNode, context);
+            return lintObjectForSpacing(node, context, config, fontSize, tokenNode);
+          }
+        }
+        parentNode.properties.forEach(findObjectStyles);
       }),
       // CSSTemplateLiteral and StyledTemplateLiteral
       // const cssTemplateLiteral = css`color: red; padding: 12px`;
       // const styledTemplateLiteral = styled.p`color: red; padding: 8px`;
       'TaggedTemplateExpression[tag.name="css"],TaggedTemplateExpression[tag.object.name="styled"],TaggedTemplateExpression[tag.callee.name="styled"]': function TaggedTemplateExpressionTagNameCssTaggedTemplateExpressionTagObjectNameStyledTaggedTemplateExpressionTagCalleeNameStyled(node) {
-        return errorBoundary(function () {
-          // To force the correct node type
-          if (!isNodeOfType(node, 'TaggedTemplateExpression')) {
-            return;
-          }
-          var processedCssLines = processCssNode(node, context);
-          if (!processedCssLines) {
-            // if we can't get a processed css we bail
-            return;
+        // To force the correct node type
+        if (!isNodeOfType(node, 'TaggedTemplateExpression')) {
+          return;
+        }
+        var processedCssLines = processCssNode(node, context);
+        if (!processedCssLines) {
+          // if we can't get a processed css we bail
+          return;
+        }
+        var globalFontSize = getFontSizeValueInScope(processedCssLines);
+        var textForSource = context.getSourceCode().getText(node.quasi);
+        var allReplacedValues = [];
+        var completeSource = processedCssLines.reduce(function (currentSource, _ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            resolvedCssLine = _ref2[0],
+            originalCssLine = _ref2[1];
+          var _resolvedCssLine$spli = resolvedCssLine.split(':'),
+            _resolvedCssLine$spli2 = _slicedToArray(_resolvedCssLine$spli, 2),
+            originalProperty = _resolvedCssLine$spli2[0],
+            resolvedCssValues = _resolvedCssLine$spli2[1];
+          var _originalCssLine$spli = originalCssLine.split(':'),
+            _originalCssLine$spli2 = _slicedToArray(_originalCssLine$spli, 2),
+            _ = _originalCssLine$spli2[0],
+            originalCssValues = _originalCssLine$spli2[1];
+          var propertyName = convertHyphenatedNameToCamelCase(originalProperty);
+          var isFontFamily = /fontFamily/.test(propertyName);
+          var replacedValuesPerProperty = [originalProperty];
+          var domains = getDomainsForProperty(propertyName, config.domains);
+          if (domains.length === 0 || !resolvedCssValues) {
+            // in both of these cases no changes should be made to the current property
+            return currentSource;
           }
-          var globalFontSize = getFontSizeValueInScope(processedCssLines);
-          var textForSource = context.getSourceCode().getText(node.quasi);
-          var allReplacedValues = [];
-          var completeSource = processedCssLines.reduce(function (currentSource, _ref) {
-            var _ref2 = _slicedToArray(_ref, 2),
-              resolvedCssLine = _ref2[0],
-              originalCssLine = _ref2[1];
-            var _resolvedCssLine$spli = resolvedCssLine.split(':'),
-              _resolvedCssLine$spli2 = _slicedToArray(_resolvedCssLine$spli, 2),
-              originalProperty = _resolvedCssLine$spli2[0],
-              resolvedCssValues = _resolvedCssLine$spli2[1];
-            var _originalCssLine$spli = originalCssLine.split(':'),
-              _originalCssLine$spli2 = _slicedToArray(_originalCssLine$spli, 2),
-              _ = _originalCssLine$spli2[0],
-              originalCssValues = _originalCssLine$spli2[1];
-            var propertyName = convertHyphenatedNameToCamelCase(originalProperty);
-            var isFontFamily = /fontFamily/.test(propertyName);
-            var replacedValuesPerProperty = [originalProperty];
-            var domains = getDomainsForProperty(propertyName, config.domains);
-            if (domains.length === 0 || !resolvedCssValues) {
-              // in both of these cases no changes should be made to the current property
+          if (domains.includes('color')) {
+            if (includesTokenString(resolvedCssValues.trim())) {
               return currentSource;
             }
-            if (domains.includes('color')) {
-              if (includesTokenString(resolvedCssValues.trim())) {
-                return currentSource;
-              }
-              if (includesHardCodedColor(resolvedCssValues)) {
-                context.report({
-                  messageId: 'hardCodedColor',
-                  node: node
-                });
-                return currentSource;
-              }
+            if (includesHardCodedColor(resolvedCssValues)) {
+              context.report({
+                messageId: 'hardCodedColor',
+                node: node
+              });
+              return currentSource;
+            }
+          }
+          if (domains.includes('spacing') || domains.includes('shape')) {
+            if (!isValidSpacingValue(resolvedCssValues, globalFontSize)) {
+              // no changes should be made to the current property
+              return currentSource;
             }
-            if (domains.includes('spacing') || domains.includes('shape')) {
-              if (!isValidSpacingValue(resolvedCssValues, globalFontSize)) {
-                // no changes should be made to the current property
-                return currentSource;
-              }
-
-              // gets the values from the associated property, numeric values or NaN
-              var processedNumericValues = getValueFromShorthand(resolvedCssValues);
-              var processedValues = splitShorthandValues(resolvedCssValues);
-              // only splits shorthand values but it does not transform NaNs so tokens are preserved
-              var originalValues = splitShorthandValues(originalCssValues);
-
-              // reconstructing the string
-              // should replace what it can and preserve the raw value for everything else
 
-              var replacementValue = processedNumericValues
-              // put together resolved value and original value on a tuple
-              .map(function (value, index) {
-                return [
-                // if emToPX conversion fails we'll default to original value
-                emToPixels(value, globalFontSize) || value, processedValues[index], originalValues[index]];
-              }).map(function (_ref3) {
-                var _ref4 = _slicedToArray(_ref3, 3),
-                  numericOrNanValue = _ref4[0],
-                  pxValue = _ref4[1],
-                  originalValue = _ref4[2];
-                if (!originalValue) {
-                  return originalValue;
-                }
-                if (isCalc(originalValue)) {
-                  context.report({
-                    node: node,
-                    messageId: 'noCalcUsage',
-                    data: {
-                      payload: "".concat(propertyName)
-                    }
-                  });
-                  return originalValue;
-                }
-                if (isTokenValueString(originalValue)) {
-                  // if the value is already valid, nothing to report or replace
-                  return originalValue;
-                }
+            // gets the values from the associated property, numeric values or NaN
+            var processedNumericValues = getValueFromShorthand(resolvedCssValues);
+            var processedValues = splitShorthandValues(resolvedCssValues);
+            // only splits shorthand values but it does not transform NaNs so tokens are preserved
+            var originalValues = splitShorthandValues(originalCssValues);
 
-                // do not replace 0 or auto with tokens
-                if (isZero(pxValue) || isAuto(pxValue)) {
-                  return originalValue;
-                }
-                if (isNaN(numericOrNanValue) && !isFontFamily) {
-                  // do not report if we have nothing to replace with
-                  return originalValue;
-                }
+            // reconstructing the string
+            // should replace what it can and preserve the raw value for everything else
 
-                // value is numeric or fontFamily, and needs replacing we'll report first
+            var replacementValue = processedNumericValues
+            // put together resolved value and original value on a tuple
+            .map(function (value, index) {
+              return [
+              // if emToPX conversion fails we'll default to original value
+              emToPixels(value, globalFontSize) || value, processedValues[index], originalValues[index]];
+            }).map(function (_ref3) {
+              var _ref4 = _slicedToArray(_ref3, 3),
+                numericOrNanValue = _ref4[0],
+                pxValue = _ref4[1],
+                originalValue = _ref4[2];
+              if (!originalValue) {
+                return originalValue;
+              }
+              if (isCalc(originalValue)) {
                 context.report({
                   node: node,
-                  messageId: 'noRawSpacingValues',
+                  messageId: 'noCalcUsage',
                   data: {
-                    payload: "".concat(propertyName, ":").concat(numericOrNanValue)
+                    payload: "".concat(propertyName)
                   }
                 });
+                return originalValue;
+              }
+              if (isTokenValueString(originalValue)) {
+                // if the value is already valid, nothing to report or replace
+                return originalValue;
+              }
 
-                // from here on we know value is numeric or a font family, so it might or might not have a token equivalent
-                var replacementNode = getTokenReplacement(propertyName, numericOrNanValue);
-                if (!replacementNode) {
-                  return originalValue;
-                }
-                var replacementToken = '${' + replacementNode.toString() + '}';
-                replacedValuesPerProperty.push(isFontFamily ? numericOrNanValue.trim() : pxValue);
-                return replacementToken;
-              }).join(' ');
-              if (replacedValuesPerProperty.length > 1) {
-                // first value is the property name, so it will always have at least 1
-                allReplacedValues.push(replacedValuesPerProperty);
+              // do not replace 0 or auto with tokens
+              if (isZero(pxValue) || isAuto(pxValue)) {
+                return originalValue;
+              }
+              if (isNaN(numericOrNanValue) && !isFontFamily) {
+                // do not report if we have nothing to replace with
+                return originalValue;
               }
 
-              // replace property:val with new property:val
-              var replacedCssLine = currentSource.replace(originalCssLine, //  padding: ${gridSize()}px;
-              "".concat(originalProperty, ": ").concat(replacementValue));
-              if (!replacedCssLine) {
-                return currentSource;
+              // value is numeric or fontFamily, and needs replacing we'll report first
+              context.report({
+                node: node,
+                messageId: 'noRawSpacingValues',
+                data: {
+                  payload: "".concat(propertyName, ":").concat(numericOrNanValue)
+                }
+              });
+
+              // from here on we know value is numeric or a font family, so it might or might not have a token equivalent
+              var replacementNode = getTokenReplacement(propertyName, numericOrNanValue);
+              if (!replacementNode) {
+                return originalValue;
               }
-              return replacedCssLine;
+              var replacementToken = '${' + replacementNode.toString() + '}';
+              replacedValuesPerProperty.push(isFontFamily ? numericOrNanValue.trim() : pxValue);
+              return replacementToken;
+            }).join(' ');
+            if (replacedValuesPerProperty.length > 1) {
+              // first value is the property name, so it will always have at least 1
+              allReplacedValues.push(replacedValuesPerProperty);
             }
-            return currentSource;
-          }, textForSource);
-          if (completeSource !== textForSource) {
-            // means we found some replacement values, we'll give the option to fix them
 
-            context.report({
-              node: node,
-              messageId: 'autofixesPossible',
-              fix: function fix(fixer) {
-                return (!tokenNode && config.applyImport ? [insertTokensImport(fixer)] : []).concat([fixer.replaceText(node.quasi, completeSource)]);
-              }
-            });
+            // replace property:val with new property:val
+            var replacedCssLine = currentSource.replace(originalCssLine, //  padding: ${gridSize()}px;
+            "".concat(originalProperty, ": ").concat(replacementValue));
+            if (!replacedCssLine) {
+              return currentSource;
+            }
+            return replacedCssLine;
           }
-        }, {
-          config: config
-        });
+          return currentSource;
+        }, textForSource);
+        if (completeSource !== textForSource) {
+          // means we found some replacement values, we'll give the option to fix them
+
+          context.report({
+            node: node,
+            messageId: 'autofixesPossible',
+            fix: function fix(fixer) {
+              return (!tokenNode && config.applyImport ? [insertTokensImport(fixer)] : []).concat([fixer.replaceText(node.quasi, completeSource)]);
+            }
+          });
+        }
       },
       // For inline JSX styles - literals (e.g. <Test color="red"/>) - color only
       'JSXAttribute > Literal': function JSXAttributeLiteral(node) {
-        return errorBoundary(function () {
-          if (config.domains.includes('color')) {
-            return lintJSXLiteralForColor(node, context, config);
-          }
-          return;
-        }, {
-          config: config
-        });
+        if (config.domains.includes('color')) {
+          return lintJSXLiteralForColor(node, context, config);
+        }
+        return;
       },
       // For inline JSX styles - members (e.g. <Test color={color.red}/>) - color only
       'JSXExpressionContainer > MemberExpression': function JSXExpressionContainerMemberExpression(node) {
-        return errorBoundary(function () {
-          if (config.domains.includes('color')) {
-            return lintJSXMemberForColor(node, context, config);
-          }
-          return;
-        }, {
-          config: config
-        });
+        if (config.domains.includes('color')) {
+          return lintJSXMemberForColor(node, context, config);
+        }
+        return;
       },
       // For inline JSX styles - identifiers (e.g. <Test color={red}/>) - color only
       'JSXExpressionContainer > Identifier': function JSXExpressionContainerIdentifier(node) {
-        return errorBoundary(function () {
-          if (config.domains.includes('color')) {
-            return lintJSXIdentifierForColor(node, context, config);
-          }
-          return;
-        }, {
-          config: config
-        });
+        if (config.domains.includes('color')) {
+          return lintJSXIdentifierForColor(node, context, config);
+        }
+        return;
       }
-    };
+    }, config);
   };
 };
 var rule = createLintRule({

package/dist/esm/rules/index.codegen.js

@@ -1,6 +1,6 @@
 /**
  * THIS FILE WAS CREATED VIA CODEGEN DO NOT MODIFY {@see http://go/af-codegen}
- * @codegen <<SignedSource::b359d356c482db0087ddfce5bd105403>>
+ * @codegen <<SignedSource::402e6eb5433560b1032e5ed926bb5564>>
  * @codegenCommand yarn workspace @atlaskit/eslint-plugin-design-system codegen
  */
 import consistentCssPropUsage from './consistent-css-prop-usage';
@@ -9,6 +9,7 @@ import ensureDesignTokenUsagePreview from './ensure-design-token-usage-preview';
 import iconLabel from './icon-label';
 import noBannedImports from './no-banned-imports';
 import noCssTaggedTemplateExpression from './no-css-tagged-template-expression';
+import noCustomIcons from './no-custom-icons';
 import noDeprecatedApis from './no-deprecated-apis';
 import noDeprecatedDesignTokenUsage from './no-deprecated-design-token-usage';
 import noDeprecatedImports from './no-deprecated-imports';
@@ -50,6 +51,7 @@ export default {
   'icon-label': iconLabel,
   'no-banned-imports': noBannedImports,
   'no-css-tagged-template-expression': noCssTaggedTemplateExpression,
+  'no-custom-icons': noCustomIcons,
   'no-deprecated-apis': noDeprecatedApis,
   'no-deprecated-design-token-usage': noDeprecatedDesignTokenUsage,
   'no-deprecated-imports': noDeprecatedImports,

package/dist/esm/rules/no-custom-icons/checks/has-prop.js

@@ -0,0 +1,6 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export function hasProp(node, propName) {
+  return isNodeOfType(node.openingElement, 'JSXOpeningElement') && node.openingElement.attributes.some(function (a) {
+    return a.type === 'JSXAttribute' && a.name.name === propName;
+  });
+}