@agilebot/eslint-plugin 0.2.2 → 0.2.3

package/{lib/rules/react/better-exhaustive-deps.js → dist/index.js}

@@ -1,11 +1,519 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var eslintUtils = require('@agilebot/eslint-utils');
+var utils = require('@typescript-eslint/utils');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+var enforceIconAlias = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce alias for @mui/icons-material imports',
+      recommended: true
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        if (
+          node.source.value !== '@mui/icons-material' &&
+          node.source.value !== 'mdi-material-ui'
+        ) {
+          return;
+        }
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== 'ImportSpecifier') {
+            return;
+          }
+          if (specifier.imported.name === specifier.local.name) {
+            context.report({
+              node,
+              message: `Import for ${node.source.value} should be aliased.`,
+              fix: fixer =>
+                fixer.replaceText(
+                  specifier,
+                  `${specifier.imported.name} as ${specifier.imported.name}Icon`
+                )
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+function getSetting(context, name) {
+  return context.settings[`agilebot/${name}`];
+}
+
+let warnedForMissingPrefix = false;
+var monorepo = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Enforce import styles for monorepo',
+      recommended: true
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        let prefix = getSetting(context, 'monorepo-scope');
+        if (!prefix) {
+          if (!warnedForMissingPrefix) {
+            console.error('Warning: agilebot/monorepo-scope is not set.');
+            warnedForMissingPrefix = true;
+          }
+          return;
+        }
+        prefix = `${prefix}/`;
+        if (typeof node.source.value !== 'string') {
+          return;
+        }
+        if (!node.source.value.startsWith(prefix)) {
+          return;
+        }
+        const values = node.source.value.split('/');
+        if (values[2] === 'src') {
+          context.report({
+            node,
+            message: `Import for ${node.source.value} should not contains src folder.`,
+            fix: fixer => {
+              const correctedPath = values
+                .filter((_, index) => index !== 2)
+                .join('/');
+              return fixer.replaceText(node.source, `'${correctedPath}'`);
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+function findFormatMessageAttrNode(node, attrName) {
+  if (
+    node.type === 'CallExpression' &&
+    (node.callee.name === 'formatMessage' || node.callee.name === '$t') &&
+    node.arguments.length > 0 &&
+    node.arguments[0].properties
+  ) {
+    return node.arguments[0].properties.find(
+      a => a.key && a.key.name === attrName
+    );
+  }
+  if (
+    node.type === 'CallExpression' &&
+    node.callee.type === 'MemberExpression' &&
+    (node.callee.object.name === 'intl' ||
+      (node.callee.object.name && node.callee.object.name.endsWith('Intl'))) &&
+    (node.callee.property.name === 'formatMessage' ||
+      node.callee.property.name === '$t')
+  ) {
+    return node.arguments[0].properties.find(
+      a => a.key && a.key.name === attrName
+    );
+  }
+}
+function findFormattedMessageAttrNode(node, attrName) {
+  if (
+    node.type === 'JSXIdentifier' &&
+    node.name === 'FormattedMessage' &&
+    node.parent &&
+    node.parent.type === 'JSXOpeningElement'
+  ) {
+    return node.parent.attributes.find(a => a.name && a.name.name === attrName);
+  }
+}
+function findAttrNodeInDefineMessages(node, attrName) {
+  if (
+    node.type === 'Property' &&
+    node.key.name === attrName &&
+    node.parent &&
+    node.parent.parent &&
+    node.parent.parent.parent &&
+    node.parent.parent.parent.parent &&
+    node.parent.parent.parent.parent.type === 'CallExpression' &&
+    node.parent.parent.parent.parent.callee.name === 'defineMessages'
+  ) {
+    return node;
+  }
+}
+function findAttrNodeInDefineMessage(node, attrName) {
+  if (
+    node.type === 'Property' &&
+    node.key.name === attrName &&
+    node.parent &&
+    node.parent.parent &&
+    node.parent.parent.type === 'CallExpression' &&
+    node.parent.parent.callee.name === 'defineMessage'
+  ) {
+    return node;
+  }
+}
+function sortedTemplateElements(node) {
+  return [...node.quasis, ...node.expressions].sort(
+    (a, b) => a.range[0] - b.range[0]
+  );
+}
+function templateLiteralDisplayStr(node) {
+  return sortedTemplateElements(node)
+    .map(e => (!e.value ? '*' : e.value.raw))
+    .join('');
+}
+
+const localeFilesKeys = {};
+function getIntlIds(context) {
+  const projectRoot = getSetting(context, 'project-root');
+  const localeFiles = getSetting(context, 'locale-files');
+  if (!localeFiles) {
+    throw new Error('localeFiles not in settings');
+  }
+  const results = [];
+  localeFiles.forEach(f => {
+    const fullPath = projectRoot ? path__namespace.join(projectRoot, f) : f;
+    const mtime = fs__namespace.lstatSync(fullPath).mtime.getTime();
+    if (
+      !localeFilesKeys[fullPath] ||
+      mtime !== localeFilesKeys[fullPath].mtime
+    ) {
+      let json;
+      if (fullPath.endsWith('.json')) {
+        json = JSON.parse(fs__namespace.readFileSync(fullPath, 'utf8'));
+      } else if (fullPath.endsWith('.ts')) {
+        json = eslintUtils.tsImport(fullPath);
+        if (typeof json === 'object' && json.default) {
+          json = json.default;
+        }
+      } else if (fullPath.endsWith('.js')) {
+        json = require(fullPath);
+        if (typeof json === 'object' && json.default) {
+          json = json.default;
+        }
+      } else {
+        throw new Error('unsupported file extension');
+      }
+      localeFilesKeys[fullPath] = {
+        keys: Object.keys(json),
+        mtime: mtime
+      };
+    }
+    results.push(...localeFilesKeys[fullPath].keys);
+  });
+  return results;
+}
+
+var idMissing = {
+  meta: {
+    docs: {
+      description: 'Validates intl message ids are in locale file',
+      category: 'Intl',
+      recommended: true
+    },
+    fixable: null,
+    schema: []
+  },
+  create: function (context) {
+    const translatedIds = getIntlIds(context);
+    const translatedIdSet = new Set(translatedIds);
+    function isLiteralTranslated(id) {
+      return translatedIdSet.has(id);
+    }
+    function isTemplateTranslated(re) {
+      return translatedIds.some(k => re.test(k));
+    }
+    function processLiteral(node) {
+      if (!isLiteralTranslated(node.value)) {
+        context.report({
+          node: node,
+          message: 'Missing id: ' + node.value
+        });
+      }
+    }
+    function processTemplateLiteral(node) {
+      const exStr = sortedTemplateElements(node)
+        .map(e => (!e.value ? '.*' : e.value.raw))
+        .join('');
+      const re = new RegExp(exStr);
+      if (!isTemplateTranslated(re)) {
+        context.report({
+          node: node,
+          message: 'Missing id pattern: ' + templateLiteralDisplayStr(node)
+        });
+      }
+    }
+    function processAttrNode(node) {
+      if (node.value.type === 'Literal') {
+        return processLiteral(node.value);
+      }
+      if (
+        node.value.type === 'JSXExpressionContainer' &&
+        node.value.expression.type === 'TemplateLiteral'
+      ) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === 'TemplateLiteral') {
+        return processTemplateLiteral(node.value);
+      }
+      context.report({
+        node: node,
+        message: 'Do not invoke intl by ' + node.value.type
+      });
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode =
+          findAttrNodeInDefineMessages(node, 'id') ||
+          findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+};
+
+var idPrefix = {
+  meta: {
+    docs: {
+      description: 'Validates intl message ids has correct prefixes',
+      category: 'Intl',
+      recommended: true
+    },
+    fixable: null,
+    schema: [
+      {
+        type: 'array',
+        items: {
+          type: 'string'
+        }
+      }
+    ]
+  },
+  create: function (context) {
+    if (context.options[0].length === 0) {
+      throw new Error('Prefixes are required in settings');
+    }
+    const hasPrefix = value =>
+      context.options[0].some(p => value.startsWith(p));
+    function report(node, value) {
+      if (!hasPrefix(value)) {
+        context.report({
+          node: node,
+          message: `Invalid id prefix: ${value}`
+        });
+      }
+    }
+    function processLiteral(node) {
+      report(node, node.value);
+    }
+    function processTemplateLiteral(node) {
+      const displayStr = templateLiteralDisplayStr(node);
+      report(node, displayStr);
+    }
+    function processAttrNode(node) {
+      if (node.value.type === 'Literal') {
+        return processLiteral(node.value);
+      }
+      if (
+        node.value.type === 'JSXExpressionContainer' &&
+        node.value.expression.type === 'TemplateLiteral'
+      ) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === 'TemplateLiteral') {
+        return processTemplateLiteral(node.value);
+      }
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode =
+          findAttrNodeInDefineMessages(node, 'id') ||
+          findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+};
+
+const usedIds = new Map();
+var idUnused = {
+  meta: {
+    docs: {
+      description: 'Finds unused intl message ids in locale file',
+      category: 'Intl',
+      recommended: true
+    },
+    fixable: null,
+    schema: []
+  },
+  create: function (context) {
+    const projectRoot = getSetting(context, 'project-root');
+    if (!projectRoot) {
+      throw new Error('projectRoot must be set in this rule');
+    }
+    if (!usedIds.has(projectRoot)) {
+      usedIds.set(projectRoot, new Set());
+    }
+    const usedIdSet = usedIds.get(projectRoot);
+    const translatedIds = getIntlIds(context);
+    const translatedIdSet = new Set(translatedIds);
+    function isLiteralTranslated(id) {
+      return translatedIdSet.has(id);
+    }
+    function isTemplateTranslated(re) {
+      return translatedIds.some(k => re.test(k));
+    }
+    function processLiteral(node) {
+      if (isLiteralTranslated(node.value)) {
+        usedIdSet.add(node.value);
+      }
+    }
+    function processTemplateLiteral(node) {
+      const exStr = sortedTemplateElements(node)
+        .map(e => (!e.value ? '.*' : e.value.raw))
+        .join('');
+      const re = new RegExp(exStr);
+      if (isTemplateTranslated(re)) ;
+    }
+    function processAttrNode(node) {
+      if (node.value.type === 'Literal') {
+        return processLiteral(node.value);
+      }
+      if (
+        node.value.type === 'JSXExpressionContainer' &&
+        node.value.expression.type === 'TemplateLiteral'
+      ) {
+        return processTemplateLiteral(node.value.expression);
+      }
+      if (node.value.type === 'TemplateLiteral') {
+        return processTemplateLiteral(node.value);
+      }
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode =
+          findAttrNodeInDefineMessages(node, 'id') ||
+          findAttrNodeInDefineMessage(node, 'id');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      'Program:exit': function () {
+        const unusedIds = [...translatedIdSet].filter(id => !usedIdSet.has(id));
+        const jsonPath = path__namespace.join(projectRoot, 'intl-unused.json');
+        fs__namespace.writeFileSync(jsonPath, JSON.stringify(unusedIds, null, 2));
+      }
+    };
+  }
+};
+
+var noDefault = {
+  meta: {
+    docs: {
+      description: 'Validates defaultMessage is not used with react-intl',
+      category: 'Intl',
+      recommended: true
+    },
+    fixable: null,
+    schema: []
+  },
+  create: function (context) {
+    function processAttrNode(node) {
+      context.report({
+        node: node,
+        message: 'Do not use defaultMessage'
+      });
+    }
+    return {
+      JSXIdentifier: function (node) {
+        const attrNode = findFormattedMessageAttrNode(node, 'defaultMessage');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      CallExpression: function (node) {
+        const attrNode = findFormatMessageAttrNode(node, 'defaultMessage');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      },
+      Property: function (node) {
+        const attrNode =
+          findAttrNodeInDefineMessages(node, 'defaultMessage') ||
+          findAttrNodeInDefineMessage(node, 'defaultMessage');
+        if (attrNode) {
+          return processAttrNode(attrNode);
+        }
+      }
+    };
+  }
+};
 
-module.exports = {
+var betterExhaustiveDeps = {
   meta: {
     type: 'suggestion',
     docs: {
@@ -58,44 +566,36 @@ module.exports = {
     ]
   },
   create(context) {
-    // Parse the `additionalHooks` regex.
     const additionalHooks =
       context.options &&
       context.options[0] &&
       context.options[0].additionalHooks
         ? new RegExp(context.options[0].additionalHooks)
         : undefined;
-
     const enableDangerousAutofixThisMayCauseInfiniteLoops =
       (context.options &&
         context.options[0] &&
         context.options[0].enableDangerousAutofixThisMayCauseInfiniteLoops) ||
       false;
-
-    // Parse the `staticHooks` object.
     const staticHooks =
       (context.options &&
         context.options[0] &&
         context.options[0].staticHooks) ||
       {};
-
     const checkMemoizedVariableIsStatic =
       (context.options &&
         context.options[0] &&
         context.options[0].checkMemoizedVariableIsStatic) ||
       false;
-
     const options = {
       additionalHooks,
       enableDangerousAutofixThisMayCauseInfiniteLoops,
       staticHooks,
       checkMemoizedVariableIsStatic
     };
-
     function reportProblem(problem) {
       if (
-        enableDangerousAutofixThisMayCauseInfiniteLoops && // Used to enable legacy behavior. Dangerous.
-        // Keep this as an option until major IDEs upgrade (including VSCode FB ESLint extension).
+        enableDangerousAutofixThisMayCauseInfiniteLoops &&
         Array.isArray(problem.suggest) &&
         problem.suggest.length > 0
       ) {
@@ -103,10 +603,7 @@ module.exports = {
       }
       context.report(problem);
     }
-
     const scopeManager = context.getSourceCode().scopeManager;
-
-    // Should be shared between visitors.
     const setStateCallSites = new WeakMap();
     const stateVariables = new WeakSet();
     const stableKnownValueCache = new WeakMap();
@@ -114,8 +611,6 @@ module.exports = {
     function memoizeWithWeakMap(fn, map) {
       return function (arg) {
         if (map.has(arg)) {
-          // to verify cache hits:
-          // console.log(arg.name)
           return map.get(arg);
         }
         const result = fn(arg);
@@ -123,9 +618,6 @@ module.exports = {
         return result;
       };
     }
-    /**
-     * Visitor for both function expressions and arrow function expressions.
-     */
     function visitFunctionWithDependencies(
       node,
       declaredDependenciesNode,
@@ -150,18 +642,7 @@ module.exports = {
             'Learn more about data fetching with Hooks: https://reactjs.org/link/hooks-data-fetching'
         });
       }
-
-      // Get the current scope.
       const scope = scopeManager.acquire(node);
-
-      // Find all our "pure scopes". On every re-render of a component these
-      // pure scopes may have changes to the variables declared within. So all
-      // variables used in our reactive hook callback but declared in a pure
-      // scope need to be listed as dependencies of our reactive hook callback.
-      //
-      // According to the rules of React you can't read a mutable value in pure
-      // scope. We can't enforce this in a lint so we trust that all variables
-      // declared outside of pure scope are indeed frozen.
       const pureScopes = new Set();
       let componentScope = null;
       {
@@ -173,18 +654,12 @@ module.exports = {
           }
           currentScope = currentScope.upper;
         }
-        // If there is no parent function scope then there are no pure scopes.
-        // The ones we've collected so far are incorrect. So don't continue with
-        // the lint.
         if (!currentScope) {
           return;
         }
         componentScope = currentScope;
       }
-
       const isArray = Array.isArray;
-
-      // Remember such values. Avoid re-running extra checks on them.
       const memoizedIsStableKnownHookValue = memoizeWithWeakMap(
         isStableKnownHookValue,
         stableKnownValueCache
@@ -193,20 +668,6 @@ module.exports = {
         isFunctionWithoutCapturedValues,
         functionWithoutCapturedValueCache
       );
-
-      // Next we'll define a few helpers that helps us
-      // tell if some values don't have to be declared as deps.
-
-      // Some are known to be stable based on Hook calls.
-      // const [state, setState] = useState() / React.useState()
-      //               ^^^ true for this reference
-      // const [state, dispatch] = useReducer() / React.useReducer()
-      //               ^^^ true for this reference
-      // const ref = useRef()
-      //       ^^^ true for this reference
-      // False for everything else.
-      // True if the value is registered in staticHooks.
-      // True if the value is from useMemo() or useCallback() and has zero deps.
       function isStableKnownHookValue(resolved) {
         if (!isArray(resolved.defs)) {
           return false;
@@ -215,7 +676,6 @@ module.exports = {
         if (def == null) {
           return false;
         }
-        // Look for `let stuff = ...`
         if (def.node.type !== 'VariableDeclarator') {
           return false;
         }
@@ -226,13 +686,8 @@ module.exports = {
         while (init.type === 'TSAsExpression') {
           init = init.expression;
         }
-        // Detect primitive constants
-        // const foo = 42
         let declaration = def.node.parent;
         if (declaration == null) {
-          // This might happen if variable is declared after the callback.
-          // In that case ESLint won't set up .parent refs.
-          // So we'll set them up manually.
           fastFindReferenceWithParent(componentScope.block, def.node.id);
           declaration = def.node.parent;
           if (declaration == null) {
@@ -246,16 +701,12 @@ module.exports = {
             typeof init.value === 'number' ||
             init.value == null)
         ) {
-          // Definitely stable
           return true;
         }
-        // Detect known Hook calls
-        // const [_, setState] = useState()
         if (init.type !== 'CallExpression') {
           return false;
         }
         let callee = init.callee;
-        // Step into `= React.something` initializer.
         if (
           callee.type === 'MemberExpression' &&
           callee.object.name === 'React' &&
@@ -270,16 +721,13 @@ module.exports = {
         const id = def.node.id;
         const { name } = callee;
         if (name === 'useRef' && id.type === 'Identifier') {
-          // useRef() return value is stable.
           return true;
         } else if (name === 'useState' || name === 'useReducer') {
-          // Only consider second value in initializing tuple stable.
           if (
             id.type === 'ArrayPattern' &&
             id.elements.length === 2 &&
             isArray(resolved.identifiers)
           ) {
-            // Is second tuple value the same reference we're checking?
             if (id.elements[1] === resolved.identifiers[0]) {
               if (name === 'useState') {
                 const references = resolved.references;
@@ -294,7 +742,6 @@ module.exports = {
                   setStateCallSites.set(reference.identifier, id.elements[0]);
                 }
               }
-              // Setter is stable.
               return true;
             } else if (id.elements[0] === resolved.identifiers[0]) {
               if (name === 'useState') {
@@ -303,47 +750,34 @@ module.exports = {
                   stateVariables.add(reference.identifier);
                 }
               }
-              // State variable itself is dynamic.
               return false;
             }
           }
         } else if (name === 'useTransition') {
-          // Only consider second value in initializing tuple stable.
           if (
             id.type === 'ArrayPattern' &&
             id.elements.length === 2 &&
-            Array.isArray(resolved.identifiers) && // Is second tuple value the same reference we're checking?
+            Array.isArray(resolved.identifiers) &&
             id.elements[1] === resolved.identifiers[0]
           ) {
-            // Setter is stable.
             return true;
           }
         } else if (
           options.checkMemoizedVariableIsStatic &&
           (name === 'useMemo' || name === 'useCallback')
         ) {
-          // check memoized value is stable
-          // useMemo(() => { ... }, []) / useCallback((...) => { ... }, [])
           const hookArgs = callee.parent.arguments;
-          // check it has dependency list
           if (hookArgs.length < 2) {
             return false;
           }
-
           const dependencies = hookArgs[1].elements;
           if (dependencies.length === 0) {
-            // no dependency, so it's stable
             return true;
           }
-
-          // check all dependency is stable
           for (const dependencyNode of dependencies) {
-            // find resolved from resolved's scope
-            // TODO: check dependencyNode is in arguments?
             const dependencyRefernece = resolved.scope.references.find(
               reference => reference.identifier === dependencyNode
             );
-
             if (
               dependencyRefernece !== undefined &&
               memoizedIsStableKnownHookValue(dependencyRefernece.resolved)
@@ -353,10 +787,8 @@ module.exports = {
               return false;
             }
           }
-
           return true;
         } else {
-          // filter regexp first
           Object.entries(options.staticHooks).forEach(([key, staticParts]) => {
             if (
               typeof staticParts === 'object' &&
@@ -366,20 +798,16 @@ module.exports = {
               options.staticHooks[name] = staticParts.value;
             }
           });
-
           if (options.staticHooks[name]) {
             const staticParts = options.staticHooks[name];
             if (staticParts === true) {
-              // entire return value is static
               return true;
             } else if (Array.isArray(staticParts)) {
-              // destructured tuple return where some elements are static
               if (
                 id.type === 'ArrayPattern' &&
                 id.elements.length <= staticParts.length &&
                 Array.isArray(resolved.identifiers)
               ) {
-                // find index of the resolved ident in the array pattern
                 const idx = id.elements.indexOf(resolved.identifiers[0]);
                 if (idx >= 0) {
                   return staticParts[idx];
@@ -389,7 +817,6 @@ module.exports = {
               typeof staticParts === 'object' &&
               id.type === 'ObjectPattern'
             ) {
-              // destructured object return where some properties are static
               const property = id.properties.find(
                 p => p.key === resolved.identifiers[0]
               );
@@ -399,11 +826,8 @@ module.exports = {
             }
           }
         }
-        // By default assume it's dynamic.
         return false;
       }
-
-      // Some are just functions that don't reference anything dynamic.
       function isFunctionWithoutCapturedValues(resolved) {
         if (!isArray(resolved.defs)) {
           return false;
@@ -415,8 +839,6 @@ module.exports = {
         if (def.node == null || def.node.id == null) {
           return false;
         }
-        // Search the direct component subscopes for
-        // top-level function definitions matching this reference.
         const fnNode = def.node;
         const childScopes = componentScope.childScopes;
         let fnScope = null;
@@ -425,15 +847,11 @@ module.exports = {
           const childScope = childScopes[i];
           const childScopeBlock = childScope.block;
           if (
-            // function handleChange() {}
             (fnNode.type === 'FunctionDeclaration' &&
               childScopeBlock === fnNode) ||
-            // const handleChange = () => {}
-            // const handleChange = function() {}
             (fnNode.type === 'VariableDeclarator' &&
               childScopeBlock.parent === fnNode)
           ) {
-            // Found it!
             fnScope = childScope;
             break;
           }
@@ -441,8 +859,6 @@ module.exports = {
         if (fnScope == null) {
           return false;
         }
-        // Does this function capture any values
-        // that are in pure scopes (aka render)?
         for (i = 0; i < fnScope.through.length; i++) {
           const ref = fnScope.through[i];
           if (ref.resolved == null) {
@@ -450,24 +866,14 @@ module.exports = {
           }
           if (
             pureScopes.has(ref.resolved.scope) &&
-            // Stable values are fine though,
-            // although we won't check functions deeper.
             !memoizedIsStableKnownHookValue(ref.resolved)
           ) {
             return false;
           }
         }
-        // If we got here, this function doesn't capture anything
-        // from render--or everything it captures is known stable.
         return true;
       }
-
-      // These are usually mistaken. Collect them.
       const currentRefsInEffectCleanup = new Map();
-
-      // Is this reference inside a cleanup function for this effect node?
-      // We can check by traversing scopes upwards  from the reference, and checking
-      // if the last "return () => " we encounter is located directly inside the effect.
       function isInsideEffectCleanup(reference) {
         let curScope = reference.from;
         let isInReturnedFunction = false;
@@ -481,26 +887,17 @@ module.exports = {
         }
         return isInReturnedFunction;
       }
-
-      // Get dependencies from all our resolved references in pure scopes.
-      // Key is dependency string, value is whether it's stable.
       const dependencies = new Map();
       const optionalChains = new Map();
       gatherDependenciesRecursively(scope);
-
       function gatherDependenciesRecursively(currentScope) {
         for (const reference of currentScope.references) {
-          // If this reference is not resolved or it is not declared in a pure
-          // scope then we don't care about this reference.
           if (!reference.resolved) {
             continue;
           }
           if (!pureScopes.has(reference.resolved.scope)) {
             continue;
           }
-
-          // Narrow the scope of a dependency if it is, say, a member expression.
-          // Then normalize the narrowed dependency.
           const referenceNode = fastFindReferenceWithParent(
             node,
             reference.identifier
@@ -510,19 +907,14 @@ module.exports = {
             dependencyNode,
             optionalChains
           );
-
-          // Accessing ref.current inside effect cleanup is bad.
           if (
-            // We're in an effect...
             isEffect &&
-            // ... and this look like accessing .current...
             dependencyNode.type === 'Identifier' &&
             (dependencyNode.parent.type === 'MemberExpression' ||
               dependencyNode.parent.type === 'OptionalMemberExpression') &&
             !dependencyNode.parent.computed &&
             dependencyNode.parent.property.type === 'Identifier' &&
             dependencyNode.parent.property.name === 'current' &&
-            // ...in a cleanup function or below...
             isInsideEffectCleanup(reference)
           ) {
             currentRefsInEffectCleanup.set(dependency, {
@@ -530,29 +922,22 @@ module.exports = {
               dependencyNode
             });
           }
-
           if (
             dependencyNode.parent.type === 'TSTypeQuery' ||
             dependencyNode.parent.type === 'TSTypeReference'
           ) {
             continue;
           }
-
           const def = reference.resolved.defs[0];
           if (def == null) {
             continue;
           }
-          // Ignore references to the function itself as it's not defined yet.
           if (def.node != null && def.node.init === node.parent) {
             continue;
           }
-          // Ignore Flow type parameters
           if (def.type === 'TypeParameter') {
             continue;
           }
-
-          // Add the dependency to a map so we can make sure it is referenced
-          // again in our dependencies array. Remember whether it's stable.
           if (!dependencies.has(dependency)) {
             const resolved = reference.resolved;
             const isStable =
@@ -566,30 +951,22 @@ module.exports = {
             dependencies.get(dependency).references.push(reference);
           }
         }
-
         for (const childScope of currentScope.childScopes) {
           gatherDependenciesRecursively(childScope);
         }
       }
-
-      // Warn about accessing .current in cleanup effects.
       currentRefsInEffectCleanup.forEach(
         ({ reference, dependencyNode }, dependency) => {
           const references = reference.resolved.references;
-          // Is React managing this ref or us?
-          // Let's see if we can find a .current assignment.
           let foundCurrentAssignment = false;
           for (const { identifier } of references) {
             const { parent } = identifier;
             if (
               parent != null &&
-              // ref.current
-              // Note: no need to handle OptionalMemberExpression because it can't be LHS.
               parent.type === 'MemberExpression' &&
               !parent.computed &&
               parent.property.type === 'Identifier' &&
               parent.property.name === 'current' &&
-              // ref.current = <something>
               parent.parent.type === 'AssignmentExpression' &&
               parent.parent.left === parent
             ) {
@@ -597,7 +974,6 @@ module.exports = {
               break;
             }
           }
-          // We only want to warn about React-managed refs.
           if (foundCurrentAssignment) {
             return;
           }
@@ -612,9 +988,6 @@ module.exports = {
           });
         }
       );
-
-      // Warn about assigning to variables in the outer scope.
-      // Those are usually bugs.
       const staleAssignments = new Set();
       function reportStaleAssignment(writeExpr, key) {
         if (staleAssignments.has(key)) {
@@ -632,8 +1005,6 @@ module.exports = {
             `${context.getSource(reactiveHook)}.`
         });
       }
-
-      // Remember which deps are stable and report bad usage first.
       const stableDependencies = new Set();
       dependencies.forEach(({ isStable, references }, key) => {
         if (isStable) {
@@ -645,15 +1016,10 @@ module.exports = {
           }
         });
       });
-
       if (staleAssignments.size > 0) {
-        // The intent isn't clear so we'll wait until you fix those first.
         return;
       }
-
       if (!declaredDependenciesNode) {
-        // Check if there are any top-level setState() calls.
-        // Those tend to lead to infinite loops.
         let setStateInsideEffectWithoutDeps = null;
         dependencies.forEach(({ references }, key) => {
           if (setStateInsideEffectWithoutDeps) {
@@ -663,20 +1029,17 @@ module.exports = {
             if (setStateInsideEffectWithoutDeps) {
               return;
             }
-
             const id = reference.identifier;
             const isSetState = setStateCallSites.has(id);
             if (!isSetState) {
               return;
             }
-
             let fnScope = reference.from;
             while (fnScope.type !== 'function') {
               fnScope = fnScope.upper;
             }
             const isDirectlyInsideEffect = fnScope.block === node;
             if (isDirectlyInsideEffect) {
-              // TODO: we could potentially ignore early returns.
               setStateInsideEffectWithoutDeps = key;
             }
           });
@@ -714,13 +1077,9 @@ module.exports = {
         }
         return;
       }
-
       const declaredDependencies = [];
       const externalDependencies = new Set();
       if (declaredDependenciesNode.type !== 'ArrayExpression') {
-        // If the declared dependencies are not an array expression then we
-        // can't verify that the user provided the correct dependencies. Tell
-        // the user this in an error.
         reportProblem({
           node: declaredDependenciesNode,
           message:
@@ -731,11 +1090,9 @@ module.exports = {
         });
       } else {
         declaredDependenciesNode.elements.forEach(declaredDependencyNode => {
-          // Skip elided elements.
           if (declaredDependencyNode == null) {
             return;
           }
-          // If we see a spread element then add a special warning.
           if (declaredDependencyNode.type === 'SpreadElement') {
             reportProblem({
               node: declaredDependencyNode,
@@ -747,8 +1104,6 @@ module.exports = {
             });
             return;
           }
-          // Try to normalize the declared dependency. If we can't then an error
-          // will be thrown. We will catch that error and report an error.
           let declaredDependency;
           try {
             declaredDependency = analyzePropertyChain(
@@ -783,12 +1138,10 @@ module.exports = {
                     'Extract it to a separate variable so it can be statically checked.'
                 });
               }
-
               return;
             }
             throw err;
           }
-
           let maybeID = declaredDependencyNode;
           while (
             maybeID.type === 'MemberExpression' ||
@@ -800,19 +1153,15 @@ module.exports = {
           const isDeclaredInComponent = !componentScope.through.some(
             ref => ref.identifier === maybeID
           );
-
-          // Add the dependency to our declared dependency map.
           declaredDependencies.push({
             key: declaredDependency,
             node: declaredDependencyNode
           });
-
           if (!isDeclaredInComponent) {
             externalDependencies.add(declaredDependency);
           }
         });
       }
-
       const {
         suggestedDependencies,
         unnecessaryDependencies,
@@ -825,17 +1174,12 @@ module.exports = {
         externalDependencies,
         isEffect
       });
-
       let suggestedDeps = suggestedDependencies;
-
       const problemCount =
         duplicateDependencies.size +
         missingDependencies.size +
         unnecessaryDependencies.size;
-
       if (problemCount === 0) {
-        // If nothing else to report, check if some dependencies would
-        // invalidate on every render.
         const constructions = scanForConstructions({
           declaredDependencies,
           declaredDependenciesNode,
@@ -846,35 +1190,24 @@ module.exports = {
           ({ construction, isUsedOutsideOfHook, depType }) => {
             const wrapperHook =
               depType === 'function' ? 'useCallback' : 'useMemo';
-
             const constructionType =
               depType === 'function' ? 'definition' : 'initialization';
-
             const defaultAdvice = `wrap the ${constructionType} of '${construction.name.name}' in its own ${wrapperHook}() Hook.`;
-
             const advice = isUsedOutsideOfHook
               ? `To fix this, ${defaultAdvice}`
               : `Move it inside the ${reactiveHookName} callback. Alternatively, ${defaultAdvice}`;
-
             const causation =
               depType === 'conditional' || depType === 'logical expression'
                 ? 'could make'
                 : 'makes';
-
             const message =
               `The '${construction.name.name}' ${depType} ${causation} the dependencies of ` +
               `${reactiveHookName} Hook (at line ${declaredDependenciesNode.loc.start.line}) ` +
               `change on every render. ${advice}`;
-
             let suggest;
-            // Only handle the simple case of variable assignments.
-            // Wrapping function declarations can mess up hoisting.
             if (
               isUsedOutsideOfHook &&
               construction.type === 'Variable' &&
-              // Objects may be mutated after construction, which would make this
-              // fix unsafe. Functions _probably_ won't be mutated, so we'll
-              // allow this fix for them.
               depType === 'function'
             ) {
               suggest = [
@@ -886,22 +1219,14 @@ module.exports = {
                         ? [`useMemo(() => { return `, '; })']
                         : ['useCallback(', ')'];
                     return [
-                      // TODO: also add an import?
                       fixer.insertTextBefore(construction.node.init, before),
-                      // TODO: ideally we'd gather deps here but it would require
-                      // restructuring the rule code. This will cause a new lint
-                      // error to appear immediately for useCallback. Note we're
-                      // not adding [] because would that changes semantics.
                       fixer.insertTextAfter(construction.node.init, after)
                     ];
                   }
                 }
               ];
             }
-            // TODO: What if the function needs to change on every render anyway?
-            // Should we suggest removing effect deps as an appropriate fix too?
             reportProblem({
-              // TODO: Why not report this at the dependency site?
               node: construction.node,
               message,
               suggest
@@ -910,24 +1235,15 @@ module.exports = {
         );
         return;
       }
-
-      // If we're going to report a missing dependency,
-      // we might as well recalculate the list ignoring
-      // the currently specified deps. This can result
-      // in some extra deduplication. We can't do this
-      // for effects though because those have legit
-      // use cases for over-specifying deps.
       if (!isEffect && missingDependencies.size > 0) {
         suggestedDeps = collectRecommendations({
           dependencies,
-          declaredDependencies: [], // Pretend we don't know
+          declaredDependencies: [],
           stableDependencies,
           externalDependencies,
           isEffect
         }).suggestedDependencies;
       }
-
-      // Alphabetize the suggestions, but only if deps were already alphabetized.
       function areDeclaredDepsAlphabetized() {
         if (declaredDependencies.length === 0) {
           return true;
@@ -939,11 +1255,6 @@ module.exports = {
       if (areDeclaredDepsAlphabetized()) {
         suggestedDeps.sort();
       }
-
-      // Most of our algorithm deals with dependency paths with optional chaining stripped.
-      // This function is the last step before printing a dependency, so now is a good time to
-      // check whether any members in our path are always used as optional-only. In that case,
-      // we will use ?. instead of . to concatenate those parts of the path.
       function formatDependency(path) {
         const members = path.split('.');
         let finalPath = '';
@@ -957,7 +1268,6 @@ module.exports = {
         }
         return finalPath;
       }
-
       function getWarningMessage(deps, singlePrefix, label, fixVerb) {
         if (deps.size === 0) {
           return null;
@@ -976,7 +1286,6 @@ module.exports = {
           } or remove the dependency array.`
         );
       }
-
       let extraWarning = '';
       if (unnecessaryDependencies.size > 0) {
         let badRef = null;
@@ -994,8 +1303,6 @@ module.exports = {
             "because mutating them doesn't re-render the component.";
         } else if (externalDependencies.size > 0) {
           const dep = [...externalDependencies][0];
-          // Don't show this warning for things that likely just got moved *inside* the callback
-          // because in that case they're clearly not referring to globals.
           if (!scope.set.has(dep)) {
             extraWarning =
               ` Outer scope values like '${dep}' aren't valid dependencies ` +
@@ -1003,10 +1310,6 @@ module.exports = {
           }
         }
       }
-
-      // `props.foo()` marks `props` as a dependency because it has
-      // a `this` value. This warning can be confusing.
-      // So if we're going to show it, append a clarification.
       if (!extraWarning && missingDependencies.has('props')) {
         const propDep = dependencies.get('props');
         if (propDep == null) {
@@ -1047,27 +1350,21 @@ module.exports = {
             `inside ${context.getSource(reactiveHook)}.`;
         }
       }
-
       if (!extraWarning && missingDependencies.size > 0) {
-        // See if the user is trying to avoid specifying a callable prop.
-        // This usually means they're unaware of useCallback.
         let missingCallbackDep = null;
         missingDependencies.forEach(missingDep => {
           if (missingCallbackDep) {
             return;
           }
-          // Is this a variable from top scope?
           const topScopeRef = componentScope.set.get(missingDep);
           const usedDep = dependencies.get(missingDep);
           if (usedDep.references[0].resolved !== topScopeRef) {
             return;
           }
-          // Is this a destructured prop?
           const def = topScopeRef.defs[0];
           if (def == null || def.name == null || def.type !== 'Parameter') {
             return;
           }
-          // Was it called in at least one case? Then it's a function.
           let isFunctionCall = false;
           let id;
           for (let i = 0; i < usedDep.references.length; i++) {
@@ -1086,9 +1383,6 @@ module.exports = {
           if (!isFunctionCall) {
             return;
           }
-          // If it's missing (i.e. in component scope) *and* it's a parameter
-          // then it is definitely coming from props destructuring.
-          // (It could also be props itself but we wouldn't be calling it then.)
           missingCallbackDep = missingDep;
         });
         if (missingCallbackDep != null) {
@@ -1098,7 +1392,6 @@ module.exports = {
             `and wrap that definition in useCallback.`;
         }
       }
-
       if (!extraWarning && missingDependencies.size > 0) {
         let setStateRecommendation = null;
         missingDependencies.forEach(missingDep => {
@@ -1112,7 +1405,6 @@ module.exports = {
           for (const reference of references) {
             id = reference.identifier;
             maybeCall = id.parent;
-            // Try to see if we have setState(someExpr(missingDep)).
             while (maybeCall != null && maybeCall !== componentScope.block) {
               if (maybeCall.type === 'CallExpression') {
                 const correspondingStateVariable = setStateCallSites.get(
@@ -1120,14 +1412,12 @@ module.exports = {
                 );
                 if (correspondingStateVariable != null) {
                   if (correspondingStateVariable.name === missingDep) {
-                    // setCount(count + 1)
                     setStateRecommendation = {
                       missingDep,
                       setter: maybeCall.callee.name,
                       form: 'updater'
                     };
                   } else if (stateVariables.has(id)) {
-                    // setCount(count + increment)
                     setStateRecommendation = {
                       missingDep,
                       setter: maybeCall.callee.name,
@@ -1136,9 +1426,6 @@ module.exports = {
                   } else {
                     const resolved = reference.resolved;
                     if (resolved != null) {
-                      // If it's a parameter *and* a missing dep,
-                      // it must be a prop or something inside a prop.
-                      // Therefore, recommend an inline reducer.
                       const def = resolved.defs[0];
                       if (def != null && def.type === 'Parameter') {
                         setStateRecommendation = {
@@ -1189,12 +1476,10 @@ module.exports = {
           }
         }
       }
-
       reportProblem({
         node: declaredDependenciesNode,
         message:
           `React Hook ${context.getSource(reactiveHook)} has ` +
-          // To avoid a long message, show the next actionable item.
           (getWarningMessage(missingDependencies, 'a', 'missing', 'include') ||
             getWarningMessage(
               unnecessaryDependencies,
@@ -1215,7 +1500,6 @@ module.exports = {
               .map(element => formatDependency(element))
               .join(', ')}]`,
             fix(fixer) {
-              // TODO: consider preserving the comments or formatting?
               return fixer.replaceText(
                 declaredDependenciesNode,
                 `[${suggestedDeps.map(element => formatDependency(element)).join(', ')}]`
@@ -1225,11 +1509,9 @@ module.exports = {
         ]
       });
     }
-
     function visitCallExpression(node) {
       const callbackIndex = getReactiveHookCallbackIndex(node.callee, options);
       if (callbackIndex === -1) {
-        // Not a React Hook call that needs deps.
         return;
       }
       const callback = node.arguments[callbackIndex];
@@ -1237,10 +1519,6 @@ module.exports = {
       const reactiveHookName = getNodeWithoutReactNamespace(reactiveHook).name;
       const declaredDependenciesNode = node.arguments[callbackIndex + 1];
       const isEffect = /Effect($|[^a-z])/g.test(reactiveHookName);
-
-      // Check whether a callback is supplied. If there is no callback supplied
-      // then the hook will not work and React will throw a TypeError.
-      // So no need to check for dependency inclusion.
       if (!callback) {
         reportProblem({
           node: reactiveHook,
@@ -1250,17 +1528,11 @@ module.exports = {
         });
         return;
       }
-
-      // Check the declared dependencies for this reactive hook. If there is no
-      // second argument then the reactive callback will re-run on every render.
-      // So no need to check for dependency inclusion.
       if (!declaredDependenciesNode && !isEffect) {
-        // These are only used for optimization.
         if (
           reactiveHookName === 'useMemo' ||
           reactiveHookName === 'useCallback'
         ) {
-          // TODO: Can this have a suggestion?
           reportProblem({
             node: reactiveHook,
             message:
@@ -1271,7 +1543,6 @@ module.exports = {
         }
         return;
       }
-
       switch (callback.type) {
         case 'FunctionExpression':
         case 'ArrowFunctionExpression':
@@ -1282,44 +1553,32 @@ module.exports = {
             reactiveHookName,
             isEffect
           );
-          return; // Handled
+          return;
         case 'Identifier':
           if (!declaredDependenciesNode) {
-            // No deps, no problems.
-            return; // Handled
+            return;
           }
-          // The function passed as a callback is not written inline.
-          // But perhaps it's in the dependencies array?
           if (
             declaredDependenciesNode.elements &&
             declaredDependenciesNode.elements.some(
               el => el && el.type === 'Identifier' && el.name === callback.name
             )
           ) {
-            // If it's already in the list of deps, we don't care because
-            // this is valid regardless.
-            return; // Handled
+            return;
           }
-          // We'll do our best effort to find it, complain otherwise.
           const variable = context.getScope().set.get(callback.name);
           if (variable == null || variable.defs == null) {
-            // If it's not in scope, we don't care.
-            return; // Handled
+            return;
           }
-          // The function passed as a callback is not written inline.
-          // But it's defined somewhere in the render scope.
-          // We'll do our best effort to find and check it, complain otherwise.
           const def = variable.defs[0];
           if (!def || !def.node) {
-            break; // Unhandled
+            break;
           }
           if (def.type !== 'Variable' && def.type !== 'FunctionName') {
-            // Parameter or an unusual pattern. Bail out.
-            break; // Unhandled
+            break;
           }
           switch (def.node.type) {
             case 'FunctionDeclaration':
-              // useEffect(() => { ... }, []);
               visitFunctionWithDependencies(
                 def.node,
                 declaredDependenciesNode,
@@ -1327,18 +1586,15 @@ module.exports = {
                 reactiveHookName,
                 isEffect
               );
-              return; // Handled
+              return;
             case 'VariableDeclarator':
               const init = def.node.init;
               if (!init) {
-                break; // Unhandled
+                break;
               }
               switch (init.type) {
-                // const effectBody = () => {...};
-                // useEffect(effectBody, []);
                 case 'ArrowFunctionExpression':
                 case 'FunctionExpression':
-                  // We can inspect this function as if it were inline.
                   visitFunctionWithDependencies(
                     init,
                     declaredDependenciesNode,
@@ -1346,23 +1602,20 @@ module.exports = {
                     reactiveHookName,
                     isEffect
                   );
-                  return; // Handled
+                  return;
               }
-              break; // Unhandled
+              break;
           }
-          break; // Unhandled
+          break;
         default:
-          // useEffect(generateEffectBody(), []);
           reportProblem({
             node: reactiveHook,
             message:
               `React Hook ${reactiveHookName} received a function whose dependencies ` +
               `are unknown. Pass an inline function instead.`
           });
-          return; // Handled
+          return;
       }
-
-      // Something unusual. Fall back to suggesting to add the body itself as a dep.
       reportProblem({
         node: reactiveHook,
         message:
@@ -1381,14 +1634,11 @@ module.exports = {
         ]
       });
     }
-
     return {
       CallExpression: visitCallExpression
     };
   }
 };
-
-// The meat of the logic.
 function collectRecommendations({
   dependencies,
   declaredDependencies,
@@ -1396,27 +1646,15 @@ function collectRecommendations({
   externalDependencies,
   isEffect
 }) {
-  // Our primary data structure.
-  // It is a logical representation of property chains:
-  // `props` -> `props.foo` -> `props.foo.bar` -> `props.foo.bar.baz`
-  //         -> `props.lol`
-  //         -> `props.huh` -> `props.huh.okay`
-  //         -> `props.wow`
-  // We'll use it to mark nodes that are *used* by the programmer,
-  // and the nodes that were *declared* as deps. Then we will
-  // traverse it to learn which deps are missing or unnecessary.
   const depTree = createDepTree();
   function createDepTree() {
     return {
-      isUsed: false, // True if used in code
-      isSatisfiedRecursively: false, // True if specified in deps
-      isSubtreeUsed: false, // True if something deeper is used by code
-      children: new Map() // Nodes for properties
+      isUsed: false,
+      isSatisfiedRecursively: false,
+      isSubtreeUsed: false,
+      children: new Map()
     };
   }
-
-  // Mark all required nodes first.
-  // Imagine exclamation marks next to each used deep property.
   dependencies.forEach((_, key) => {
     const node = getOrCreateNodeByPath(depTree, key);
     node.isUsed = true;
@@ -1424,9 +1662,6 @@ function collectRecommendations({
       parent.isSubtreeUsed = true;
     });
   });
-
-  // Mark all satisfied nodes.
-  // Imagine checkmarks next to each declared dependency.
   declaredDependencies.forEach(({ key }) => {
     const node = getOrCreateNodeByPath(depTree, key);
     node.isSatisfiedRecursively = true;
@@ -1435,8 +1670,6 @@ function collectRecommendations({
     const node = getOrCreateNodeByPath(depTree, key);
     node.isSatisfiedRecursively = true;
   });
-
-  // Tree manipulation helpers.
   function getOrCreateNodeByPath(rootNode, path) {
     const keys = path.split('.');
     let node = rootNode;
@@ -1462,8 +1695,6 @@ function collectRecommendations({
       node = child;
     }
   }
-
-  // Now we can learn which dependencies are missing or necessary.
   const missingDependencies = new Set();
   const satisfyingDependencies = new Set();
   scanTreeRecursively(
@@ -1477,19 +1708,12 @@ function collectRecommendations({
       const path = keyToPath(key);
       if (child.isSatisfiedRecursively) {
         if (child.isSubtreeUsed) {
-          // Remember this dep actually satisfied something.
           satisfyingPaths.add(path);
         }
-        // It doesn't matter if there's something deeper.
-        // It would be transitively satisfied since we assume immutability.
-        // `props.foo` is enough if you read `props.foo.id`.
         return;
       }
       if (child.isUsed) {
-        // Remember that no declared deps satisfied this node.
         missingPaths.add(path);
-        // If we got here, nothing in its subtree was satisfied.
-        // No need to search further.
         return;
       }
       scanTreeRecursively(
@@ -1500,19 +1724,14 @@ function collectRecommendations({
       );
     });
   }
-
-  // Collect suggestions in the order they were originally specified.
   const suggestedDependencies = [];
   const unnecessaryDependencies = new Set();
   const duplicateDependencies = new Set();
   declaredDependencies.forEach(({ key }) => {
-    // Does this declared dep satisfy a real need?
     if (satisfyingDependencies.has(key)) {
       if (!suggestedDependencies.includes(key)) {
-        // Good one.
         suggestedDependencies.push(key);
       } else {
-        // Duplicate.
         duplicateDependencies.add(key);
       }
     } else if (
@@ -1520,24 +1739,16 @@ function collectRecommendations({
       !key.endsWith('.current') &&
       !externalDependencies.has(key)
     ) {
-      // Effects are allowed extra "unnecessary" deps.
-      // Such as resetting scroll when ID changes.
-      // Consider them legit.
-      // The exception is ref.current which is always wrong.
       if (!suggestedDependencies.includes(key)) {
         suggestedDependencies.push(key);
       }
     } else {
-      // It's definitely not needed.
       unnecessaryDependencies.add(key);
     }
   });
-
-  // Then add the missing ones at the end.
   missingDependencies.forEach(key => {
     suggestedDependencies.push(key);
   });
-
   return {
     suggestedDependencies,
     unnecessaryDependencies,
@@ -1545,9 +1756,6 @@ function collectRecommendations({
     missingDependencies
   };
 }
-
-// If the node will result in constructing a referentially unique value, return
-// its human readable type name, else return null.
 function getConstructionExpressionType(node) {
   switch (node.type) {
     case 'ObjectExpression':
@@ -1598,9 +1806,6 @@ function getConstructionExpressionType(node) {
   }
   return null;
 }
-
-// Finds variables declared as dependencies
-// that would invalidate on every render.
 function scanForConstructions({
   declaredDependencies,
   declaredDependenciesNode,
@@ -1613,20 +1818,14 @@ function scanForConstructions({
       if (ref == null) {
         return null;
       }
-
       const node = ref.defs[0];
       if (node == null) {
         return null;
       }
-      // const handleChange = function () {}
-      // const handleChange = () => {}
-      // const foo = {}
-      // const foo = []
-      // etc.
       if (
         node.type === 'Variable' &&
         node.node.type === 'VariableDeclarator' &&
-        node.node.id.type === 'Identifier' && // Ensure this is not destructed assignment
+        node.node.id.type === 'Identifier' &&
         node.node.init != null
       ) {
         const constantExpressionType = getConstructionExpressionType(
@@ -1636,32 +1835,26 @@ function scanForConstructions({
           return [ref, constantExpressionType];
         }
       }
-      // function handleChange() {}
       if (
         node.type === 'FunctionName' &&
         node.node.type === 'FunctionDeclaration'
       ) {
         return [ref, 'function'];
       }
-
-      // class Foo {}
       if (node.type === 'ClassName' && node.node.type === 'ClassDeclaration') {
         return [ref, 'class'];
       }
       return null;
     })
     .filter(Boolean);
-
   function isUsedOutsideOfHook(ref) {
     let foundWriteExpr = false;
     for (let i = 0; i < ref.references.length; i++) {
       const reference = ref.references[i];
       if (reference.writeExpr) {
         if (foundWriteExpr) {
-          // Two writes to the same function.
           return true;
         }
-        // Ignore first write as it's not usage.
         foundWriteExpr = true;
         continue;
       }
@@ -1670,8 +1863,7 @@ function scanForConstructions({
         currentScope = currentScope.upper;
       }
       if (
-        currentScope !== scope && // This reference is outside the Hook callback.
-        // It can only be legit if it's the deps array.
+        currentScope !== scope &&
         !isAncestorNodeOf(declaredDependenciesNode, reference.identifier)
       ) {
         return true;
@@ -1679,21 +1871,12 @@ function scanForConstructions({
     }
     return false;
   }
-
   return constructions.map(([ref, depType]) => ({
     construction: ref.defs[0],
     depType,
     isUsedOutsideOfHook: isUsedOutsideOfHook(ref)
   }));
 }
-
-/**
- * Assuming () means the passed/returned node:
- * (props) => (props)
- * props.(foo) => (props.foo)
- * props.foo.(bar) => (props).foo.bar
- * props.foo.bar.(baz) => (props).foo.bar.baz
- */
 function getDependency(node) {
   if (
     (node.parent.type === 'MemberExpression' ||
@@ -1710,7 +1893,6 @@ function getDependency(node) {
   ) {
     return getDependency(node.parent);
   } else if (
-    // Note: we don't check OptionalMemberExpression because it can't be LHS.
     node.type === 'MemberExpression' &&
     node.parent &&
     node.parent.type === 'AssignmentExpression' &&
@@ -1720,40 +1902,21 @@ function getDependency(node) {
   }
   return node;
 }
-
-/**
- * Mark a node as either optional or required.
- * Note: If the node argument is an OptionalMemberExpression, it doesn't necessarily mean it is optional.
- * It just means there is an optional member somewhere inside.
- * This particular node might still represent a required member, so check .optional field.
- */
 function markNode(node, optionalChains, result) {
   if (optionalChains) {
     if (node.optional) {
-      // We only want to consider it optional if *all* usages were optional.
       if (!optionalChains.has(result)) {
-        // Mark as (maybe) optional. If there's a required usage, this will be overridden.
         optionalChains.set(result, true);
       }
     } else {
-      // Mark as required.
       optionalChains.set(result, false);
     }
   }
 }
-
-/**
- * Assuming () means the passed node.
- * (foo) -> 'foo'
- * foo(.)bar -> 'foo.bar'
- * foo.bar(.)baz -> 'foo.bar.baz'
- * Otherwise throw.
- */
 function analyzePropertyChain(node, optionalChains) {
   if (node.type === 'Identifier' || node.type === 'JSXIdentifier') {
     const result = node.name;
     if (optionalChains) {
-      // Mark as required.
       optionalChains.set(result, false);
     }
     return result;
@@ -1771,11 +1934,9 @@ function analyzePropertyChain(node, optionalChains) {
     return result;
   } else if (node.type === 'ChainExpression' && !node.computed) {
     const expression = node.expression;
-
     if (expression.type === 'CallExpression') {
       throw new Error(`Unsupported node type: ${expression.type}`);
     }
-
     const object = analyzePropertyChain(expression.object, optionalChains);
     const property = analyzePropertyChain(expression.property, null);
     const result = `${object}.${property}`;
@@ -1784,7 +1945,6 @@ function analyzePropertyChain(node, optionalChains) {
   }
   throw new Error(`Unsupported node type: ${node.type}`);
 }
-
 function getNodeWithoutReactNamespace(node) {
   if (
     node.type === 'MemberExpression' &&
@@ -1797,12 +1957,6 @@ function getNodeWithoutReactNamespace(node) {
   }
   return node;
 }
-
-// What's the index of callback that needs to be analyzed for a given Hook?
-// -1 if it's not a Hook we care about (e.g. useState).
-// 0 for useEffect/useMemo/useCallback(fn).
-// 1 for useImperativeHandle(ref, fn).
-// For additionally configured Hooks, assume that they're like useEffect (0).
 function getReactiveHookCallbackIndex(calleeNode, options) {
   const node = getNodeWithoutReactNamespace(calleeNode);
   if (node.type !== 'Identifier') {
@@ -1813,15 +1967,11 @@ function getReactiveHookCallbackIndex(calleeNode, options) {
     case 'useLayoutEffect':
     case 'useCallback':
     case 'useMemo':
-      // useEffect(fn)
       return 0;
     case 'useImperativeHandle':
-      // useImperativeHandle(ref, fn)
       return 1;
     default:
       if (node === calleeNode && options && options.additionalHooks) {
-        // Allow the user to provide a regular expression which enables the lint to
-        // target custom reactive hooks.
         let name;
         try {
           name = analyzePropertyChain(node, null);
@@ -1836,32 +1986,17 @@ function getReactiveHookCallbackIndex(calleeNode, options) {
       return -1;
   }
 }
-
-/**
- * ESLint won't assign node.parent to references from context.getScope()
- *
- * So instead we search for the node from an ancestor assigning node.parent
- * as we go. This mutates the AST.
- *
- * This traversal is:
- * - optimized by only searching nodes with a range surrounding our target node
- * - agnostic to AST node types, it looks for `{ type: string, ... }`
- */
 function fastFindReferenceWithParent(start, target) {
   const queue = [start];
   let item = null;
-
   while (queue.length > 0) {
     item = queue.shift();
-
     if (isSameIdentifier(item, target)) {
       return item;
     }
-
     if (!isAncestorNodeOf(item, target)) {
       continue;
     }
-
     for (const [key, value] of Object.entries(item)) {
       if (key === 'parent') {
         continue;
@@ -1870,7 +2005,6 @@ function fastFindReferenceWithParent(start, target) {
         value.parent = item;
         queue.push(value);
       } else if (Array.isArray(value)) {
-        // eslint-disable-next-line no-loop-func -- FIXME
         value.forEach(val => {
           if (isNodeLike(val)) {
             val.parent = item;
@@ -1880,10 +2014,8 @@ function fastFindReferenceWithParent(start, target) {
       }
     }
   }
-
   return null;
 }
-
 function joinEnglish(arr) {
   let s = '';
   for (let i = 0; i < arr.length; i++) {
@@ -1898,7 +2030,6 @@ function joinEnglish(arr) {
   }
   return s;
 }
-
 function isNodeLike(val) {
   return (
     typeof val === 'object' &&
@@ -1907,7 +2038,6 @@ function isNodeLike(val) {
     typeof val.type === 'string'
   );
 }
-
 function isSameIdentifier(a, b) {
   return (
     (a.type === 'Identifier' || a.type === 'JSXIdentifier') &&
@@ -1917,7 +2047,533 @@ function isSameIdentifier(a, b) {
     a.range[1] === b.range[1]
   );
 }
-
 function isAncestorNodeOf(a, b) {
   return a.range[0] <= b.range[0] && a.range[1] >= b.range[1];
 }
+
+const Components = require('eslint-plugin-react/lib/util/Components');
+var hookUseRef = {
+  meta: {
+    docs: {
+      description: 'Ensure naming of useRef hook value.',
+      recommended: false
+    },
+    schema: [],
+    type: 'suggestion',
+    hasSuggestions: true
+  },
+  create: Components.detect((context, component, util) => ({
+    CallExpression(node) {
+      const isImmediateReturn =
+        node.parent && node.parent.type === 'ReturnStatement';
+      if (isImmediateReturn || !util.isReactHookCall(node, ['useRef'])) {
+        return;
+      }
+      if (node.parent.id.type !== 'Identifier') {
+        return;
+      }
+      const variable = node.parent.id.name;
+      if (!variable.endsWith('Ref')) {
+        context.report({
+          node: node,
+          message: 'useRef call is not end with "Ref"'
+        });
+      }
+    }
+  }))
+};
+
+var noInlineStyles = {
+  meta: {
+    docs: {
+      description: 'Disallow style props on components and DOM Nodes',
+      category: 'Best Practices',
+      recommended: false
+    },
+    messages: {
+      disallowInlineStyles:
+        'Avoid using inline styles, use sx prop or tss-react or styled-component instead'
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          allowedFor: {
+            type: 'array',
+            uniqueItems: true,
+            items: { type: 'string' }
+          }
+        }
+      }
+    ]
+  },
+  create(context) {
+    const configuration = context.options[0] || {};
+    const allowedFor = configuration.allowedFor || [];
+    function checkComponent(node) {
+      const parentName = node.parent.name;
+      const tag =
+        parentName.name ||
+        `${parentName.object.name}.${parentName.property.name}`;
+      const componentName = parentName.name || parentName.property.name;
+      if (
+        componentName &&
+        typeof componentName[0] === 'string' &&
+        componentName[0] !== componentName[0].toUpperCase()
+      ) {
+        return;
+      }
+      if (allowedFor.includes(tag)) {
+        return;
+      }
+      const prop = node.name.name;
+      if (prop === 'style') {
+        context.report({
+          node,
+          messageId: 'disallowInlineStyles'
+        });
+      }
+    }
+    function checkDOMNodes(node) {
+      const tag = node.parent.name.name;
+      if (
+        !(tag && typeof tag === 'string' && tag[0] !== tag[0].toUpperCase())
+      ) {
+        return;
+      }
+      if (allowedFor.includes(tag)) {
+        return;
+      }
+      const prop = node.name.name;
+      if (prop === 'style') {
+        context.report({
+          node,
+          messageId: 'disallowInlineStyles'
+        });
+      }
+    }
+    return {
+      JSXAttribute(node) {
+        checkComponent(node);
+        checkDOMNodes(node);
+      }
+    };
+  }
+};
+
+function* updateImportStatement(context, fixer, key) {
+  const sourceCode = context.getSourceCode();
+  const importNode = sourceCode.ast.body.find(
+    node => node.type === 'ImportDeclaration' && node.source.value === 'react'
+  );
+  if (!importNode) {
+    yield fixer.insertTextBefore(
+      sourceCode.ast.body[0],
+      `import { ${key} } from 'react';\n`
+    );
+    return;
+  }
+  if (
+    importNode.specifiers.length === 1 &&
+    importNode.specifiers[0].type === 'ImportDefaultSpecifier'
+  ) {
+    yield fixer.insertTextAfter(importNode.specifiers[0], `, { ${key} }`);
+    return;
+  }
+  const alreadyImportedKeys = importNode.specifiers
+    .filter(specifier => specifier.type === 'ImportSpecifier')
+    .map(specifier => specifier.imported.name);
+  if (alreadyImportedKeys.includes(key)) {
+    return;
+  }
+  yield fixer.insertTextAfter([...importNode.specifiers].pop(), `, ${key}`);
+}
+var preferNamedPropertyAccess = utils.ESLintUtils.RuleCreator.withoutDocs({
+  defaultOptions: [],
+  meta: {
+    type: 'layout',
+    fixable: 'code',
+    docs: {
+      description:
+        'Enforce importing each member of React namespace separately instead of accessing them through React namespace'
+    },
+    messages: {
+      illegalReactPropertyAccess:
+        'Illegal React property access: {{name}}. Use named import instead.'
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      TSQualifiedName(node) {
+        if (
+          ('name' in node.left && node.left.name !== 'React') ||
+          ('name' in node.right && node.right.name.endsWith('Event'))
+        ) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: 'illegalReactPropertyAccess',
+          data: {
+            name: node.right.name
+          },
+          *fix(fixer) {
+            yield fixer.replaceText(node, node.right.name);
+            yield* updateImportStatement(context, fixer, node.right.name);
+          }
+        });
+      },
+      MemberExpression(node) {
+        if (node.object.name !== 'React') {
+          return;
+        }
+        context.report({
+          node,
+          messageId: 'illegalReactPropertyAccess',
+          data: {
+            name: node.property.name
+          },
+          *fix(fixer) {
+            yield fixer.replaceText(node, node.property.name);
+            yield* updateImportStatement(context, fixer, node.property.name);
+          }
+        });
+      }
+    };
+  }
+});
+
+function getBasicIdentifier(node) {
+  if (node.type === 'Identifier') {
+    return node.name;
+  }
+  if (node.type === 'Literal') {
+    return node.value;
+  }
+  if (node.type === 'TemplateLiteral') {
+    if (node.expressions.length > 0) {
+      return null;
+    }
+    return node.quasis[0].value.raw;
+  }
+  return null;
+}
+function getBaseIdentifier(node) {
+  switch (node.type) {
+    case 'Identifier': {
+      return node;
+    }
+    case 'CallExpression': {
+      return getBaseIdentifier(node.callee);
+    }
+    case 'MemberExpression': {
+      return getBaseIdentifier(node.object);
+    }
+  }
+  return null;
+}
+function getStyesObj(node) {
+  const isMakeStyles = node.callee.name === 'makeStyles';
+  const isModernApi =
+    node.callee.type === 'MemberExpression' &&
+    node.callee.property.name === 'create' &&
+    getBaseIdentifier(node.callee.object) &&
+    getBaseIdentifier(node.callee.object).name === 'tss';
+  if (!isMakeStyles && !isModernApi) {
+    return;
+  }
+  const styles = (() => {
+    if (isMakeStyles) {
+      return node.parent.arguments[0];
+    }
+    if (isModernApi) {
+      return node.callee.parent.arguments[0];
+    }
+  })();
+  if (!styles) {
+    return;
+  }
+  switch (styles.type) {
+    case 'ObjectExpression':
+      return styles;
+    case 'ArrowFunctionExpression':
+      {
+        const { body } = styles;
+        switch (body.type) {
+          case 'ObjectExpression':
+            return body;
+          case 'BlockStatement': {
+            let stylesObj;
+            body.body.forEach(bodyNode => {
+              if (
+                bodyNode.type === 'ReturnStatement' &&
+                bodyNode.argument.type === 'ObjectExpression'
+              ) {
+                stylesObj = bodyNode.argument;
+              }
+            });
+            return stylesObj;
+          }
+        }
+      }
+      break;
+  }
+}
+function isCamelCase(value) {
+  return /^[a-z][a-zA-Z0-9]*$/.test(value);
+}
+
+var classNaming = {
+  meta: {
+    type: 'problem'
+  },
+  create: function rule(context) {
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (stylesObj === undefined) {
+          return;
+        }
+        stylesObj.properties.forEach(property => {
+          if (property.computed) {
+            return;
+          }
+          if (
+            property.type === 'ExperimentalSpreadProperty' ||
+            property.type === 'SpreadElement'
+          ) {
+            return;
+          }
+          const className = property.key.value || property.key.name;
+          if (!isCamelCase(className)) {
+            context.report({
+              node: property,
+              message: `Class \`${className}\` must be camelCase in TSS.`
+            });
+          }
+        });
+      }
+    };
+  }
+};
+
+var noColorValue = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce the use of color variables instead of color codes within TSS'
+    }
+  },
+  create: function (context) {
+    const parserOptions = context.parserOptions;
+    if (!parserOptions || !parserOptions.project) {
+      return {};
+    }
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (!stylesObj) {
+          return;
+        }
+        function checkColorLiteral(value) {
+          if (value.type === 'Literal' && typeof value.value === 'string') {
+            const colorCodePattern =
+              /#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})|rgb\?\(\s*(\d{1,3}\s*,\s*){2}\d{1,3}(?:\s*,\s*\d*(?:\.\d+)?)?\s*\)/g;
+            const isColorCode = colorCodePattern.test(value.value);
+            if (isColorCode) {
+              context.report({
+                node: value,
+                message: 'Use color variables instead of color codes in TSS.'
+              });
+            }
+          }
+        }
+        function loopStylesObj(obj) {
+          if (obj && obj.type === 'ObjectExpression') {
+            obj.properties.forEach(property => {
+              if (property.type === 'Property' && property.value) {
+                if (property.value.type === 'ObjectExpression') {
+                  loopStylesObj(property.value);
+                } else {
+                  checkColorLiteral(property.value);
+                }
+              }
+            });
+          }
+        }
+        loopStylesObj(stylesObj);
+      }
+    };
+  }
+};
+
+var unusedClasses = {
+  meta: {
+    type: 'problem'
+  },
+  create: function rule(context) {
+    const usedClasses = {};
+    const definedClasses = {};
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (stylesObj === undefined) {
+          return;
+        }
+        stylesObj.properties.forEach(property => {
+          if (property.computed) {
+            return;
+          }
+          if (
+            property.type === 'ExperimentalSpreadProperty' ||
+            property.type === 'SpreadElement'
+          ) {
+            return;
+          }
+          definedClasses[property.key.value || property.key.name] = property;
+        });
+      },
+      MemberExpression(node) {
+        if (
+          node.object.type === 'Identifier' &&
+          node.object.name === 'classes'
+        ) {
+          const whichClass = getBasicIdentifier(node.property);
+          if (whichClass) {
+            usedClasses[whichClass] = true;
+          }
+          return;
+        }
+        const classIdentifier = getBasicIdentifier(node.property);
+        if (!classIdentifier) {
+          return;
+        }
+        if (classIdentifier !== 'classes') {
+          return;
+        }
+        const { parent } = node;
+        if (parent.type !== 'MemberExpression') {
+          return;
+        }
+        if (
+          node.object.object &&
+          node.object.object.type !== 'ThisExpression'
+        ) {
+          return;
+        }
+        const propsIdentifier = getBasicIdentifier(parent.object);
+        if (propsIdentifier && propsIdentifier !== 'props') {
+          return;
+        }
+        if (!propsIdentifier && parent.object.type !== 'MemberExpression') {
+          return;
+        }
+        if (parent.parent.type === 'MemberExpression') {
+          return;
+        }
+        const parentClassIdentifier = getBasicIdentifier(parent.property);
+        if (parentClassIdentifier) {
+          usedClasses[parentClassIdentifier] = true;
+        }
+      },
+      'Program:exit': () => {
+        Object.keys(definedClasses).forEach(definedClassKey => {
+          if (!usedClasses[definedClassKey]) {
+            context.report({
+              node: definedClasses[definedClassKey],
+              message: `Class \`${definedClassKey}\` is unused`
+            });
+          }
+        });
+      }
+    };
+  }
+};
+
+var noUnnecessaryTemplateLiterals = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Check if a template string contains only one ${}',
+      recommended: true
+    },
+    fixable: 'code',
+    schema: []
+  },
+  create(context) {
+    return {
+      TemplateLiteral(node) {
+        const code = context.sourceCode.getText(node);
+        if (
+          code.startsWith('`${') &&
+          code.endsWith('}`') &&
+          code.split('${').length === 2
+        ) {
+          context.report({
+            node,
+            message: 'Unnecessary template string with only one ${}.',
+            fix(fixer) {
+              return fixer.replaceText(
+                node,
+                code.substring(3, code.length - 2)
+              );
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+var ruleFiles = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  src_rules_import_enforce_icon_alias: enforceIconAlias,
+  src_rules_import_monorepo: monorepo,
+  src_rules_intl_id_missing: idMissing,
+  src_rules_intl_id_prefix: idPrefix,
+  src_rules_intl_id_unused: idUnused,
+  src_rules_intl_no_default: noDefault,
+  src_rules_react_better_exhaustive_deps: betterExhaustiveDeps,
+  src_rules_react_hook_use_ref: hookUseRef,
+  src_rules_react_no_inline_styles: noInlineStyles,
+  src_rules_react_prefer_named_property_access: preferNamedPropertyAccess,
+  src_rules_stylistic_no_unnecessary_template_literals: noUnnecessaryTemplateLiterals,
+  src_rules_tss_class_naming: classNaming,
+  src_rules_tss_no_color_value: noColorValue,
+  src_rules_tss_unused_classes: unusedClasses
+});
+
+const rules = {};
+Object.keys(ruleFiles).forEach(key => {
+  const ruleKey = key.replace(/^src_rules_/, '');
+  const finalKey = ruleKey.replace(/_/, '/').replace(/_/g, '-');
+  rules[finalKey] = ruleFiles[key];
+});
+var index = {
+  rules,
+  configs: {
+    recommended: {
+      plugins: ['@agilebot'],
+      rules: {
+        '@agilebot/react/prefer-named-property-access': 'error',
+        '@agilebot/react/hook-use-ref': 'warn',
+        '@agilebot/react/no-inline-styles': 'error',
+        '@agilebot/tss/unused-classes': 'warn',
+        '@agilebot/tss/no-color-value': 'error',
+        '@agilebot/tss/class-naming': 'error',
+        '@agilebot/import/enforce-icon-alias': 'error',
+        '@agilebot/import/monorepo': 'error',
+        '@agilebot/stylistic/no-unnecessary-template-literals': 'error'
+      },
+      settings: {
+        react: {
+          version: '18.0.0'
+        }
+      }
+    }
+  }
+};
+
+module.exports = index;