@atlaskit/eslint-plugin-design-system 10.9.0 → 10.10.1

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;
+  });
+}

package/dist/esm/rules/no-custom-icons/checks/is-from-import-source.js

@@ -0,0 +1,36 @@
+import { isImportedJSXElement } from './is-imported-jsx-element';
+export function createIsFromImportSourceFor() {
+  for (var _len = arguments.length, importSources = new Array(_len), _key = 0; _key < _len; _key++) {
+    importSources[_key] = arguments[_key];
+  }
+  var literalImportSources = importSources.filter(function (s) {
+    return typeof s === 'string';
+  });
+  var matchImportSources = importSources.filter(function (s) {
+    return s instanceof RegExp;
+  });
+  var varImportSourceMap = new Map();
+  function isFromImportSource(node) {
+    return isImportedJSXElement(node) && varImportSourceMap.has(node.openingElement.name.name);
+  }
+  isFromImportSource.importDeclarationHook = function (node) {
+    var source = node.source.value;
+    if (typeof source !== 'string' || !(literalImportSources.includes(source) || matchImportSources.some(function (r) {
+      return r.test(source);
+    }))) {
+      return;
+    }
+    node.specifiers.filter(function (spec) {
+      return ['ImportSpecifier', 'ImportDefaultSpecifier'].includes(spec.type);
+    }).forEach(function (spec) {
+      return varImportSourceMap.set(spec.local.name, source);
+    });
+  };
+  isFromImportSource.getImportSource = function (node) {
+    if (!isFromImportSource(node)) {
+      throw new Error('Node is not an imported JSX element');
+    }
+    return varImportSourceMap.get(node.openingElement.name.name);
+  };
+  return isFromImportSource;
+}

package/dist/esm/rules/no-custom-icons/checks/is-imported-jsx-element.js

@@ -0,0 +1,4 @@
+import { isNodeOfType } from 'eslint-codemod-utils';
+export function isImportedJSXElement(node) {
+  return isNodeOfType(node, 'JSXElement') && isNodeOfType(node.openingElement.name, 'JSXIdentifier');
+}

package/dist/esm/rules/no-custom-icons/index.js

@@ -0,0 +1,61 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+
+import { createLintRule } from '../utils/create-rule';
+import { errorBoundary } from '../utils/error-boundary';
+import { hasProp } from './checks/has-prop';
+import { createIsFromImportSourceFor } from './checks/is-from-import-source';
+var rule = createLintRule({
+  meta: {
+    name: 'no-custom-icons',
+    type: 'problem',
+    docs: {
+      description: 'Enforces custom glyph icons are used.',
+      recommended: false,
+      severity: 'warn'
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        centralLocation: {
+          type: 'string'
+        },
+        failSilently: {
+          type: 'boolean'
+        }
+      },
+      additionalProperties: false
+    }],
+    messages: {
+      noCustomIcons: "Custom icons from {{importSource}} are no longer supported. Migrate to an icon from '@atlaskit/(icon-labs|icon/core|icon/utility)'{{locationMessage}}.\n[Migration guide](https://hello.atlassian.net/wiki/spaces/DST/pages/3748692796/New+ADS+iconography+-+Code+migration+guide)."
+    }
+  },
+  create: function create(context) {
+    var _context$options$;
+    var isIconBase = createIsFromImportSourceFor('@atlaskit/icon', '@atlaskit/icon/base');
+    var _ref = (_context$options$ = context.options[0]) !== null && _context$options$ !== void 0 ? _context$options$ : {},
+      _ref$centralLocation = _ref.centralLocation,
+      centralLocation = _ref$centralLocation === void 0 ? '' : _ref$centralLocation,
+      _ref$failSilently = _ref.failSilently,
+      failSilently = _ref$failSilently === void 0 ? false : _ref$failSilently;
+    var locationMessage = centralLocation ? " or move the icon to '".concat(centralLocation, "'") : '';
+    return errorBoundary({
+      JSXElement: function JSXElement(node) {
+        var _isIconBase$getImport;
+        if (!isIconBase(node) || !hasProp(node, 'glyph')) {
+          return;
+        }
+        var importSource = (_isIconBase$getImport = isIconBase.getImportSource(node)) !== null && _isIconBase$getImport !== void 0 ? _isIconBase$getImport : '';
+        context.report({
+          node: node.openingElement,
+          messageId: 'noCustomIcons',
+          data: {
+            importSource: importSource,
+            locationMessage: locationMessage
+          }
+        });
+      },
+      ImportDeclaration: isIconBase.importDeclarationHook
+    }, failSilently);
+  }
+});
+export default rule;