@agilebot/eslint-plugin 0.1.3 → 0.1.4

package/lib/rules/react/prefer-named-property-access.js

@@ -1,105 +1,105 @@
-const { ESLintUtils } = require('@typescript-eslint/utils');
-
-/**
- * Auto-fix util.
- * Ensures that passed key is imported from 'react' package.
- */
-function* updateImportStatement(context, fixer, key) {
-  const sourceCode = context.getSourceCode();
-  const importNode = sourceCode.ast.body.find(
-    node => node.type === 'ImportDeclaration' && node.source.value === 'react'
-  );
-
-  // No import from 'react' - create import statement
-  if (!importNode) {
-    yield fixer.insertTextBefore(
-      sourceCode.ast.body[0],
-      `import { ${key} } from 'react';\n`
-    );
-
-    return;
-  }
-
-  // Only default import from 'react' - add named imports section
-  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);
-
-  // Named imports section is present and current key is already imported - do nothing
-  if (alreadyImportedKeys.includes(key)) {
-    return;
-  }
-
-  // Named imports section is present and current key is not imported yet - add it to named imports section
-  yield fixer.insertTextAfter([...importNode.specifiers].pop(), `, ${key}`);
-}
-
-/** @type {import('eslint').Rule.RuleModule} */
-module.exports = 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',
-      category: 'Layout & Formatting'
-    },
-    messages: {
-      illegalReactPropertyAccess:
-        'Illegal React property access: {{name}}. Use named import instead.'
-    }
-  },
-
-  create(context) {
-    return {
-      // Analyze TS types declarations
-      TSQualifiedName(node) {
-        // Do nothing to types that are ending with 'Event' as they will overlap with global event types otherwise
-        if (node.left.name !== 'React' || 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);
-          }
-        });
-      },
-
-      // Analyze expressions for React.* access
-      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);
-          }
-        });
-      }
-    };
-  }
-});
+const { ESLintUtils } = require('@typescript-eslint/utils');
+
+/**
+ * Auto-fix util.
+ * Ensures that passed key is imported from 'react' package.
+ */
+function* updateImportStatement(context, fixer, key) {
+  const sourceCode = context.getSourceCode();
+  const importNode = sourceCode.ast.body.find(
+    node => node.type === 'ImportDeclaration' && node.source.value === 'react'
+  );
+
+  // No import from 'react' - create import statement
+  if (!importNode) {
+    yield fixer.insertTextBefore(
+      sourceCode.ast.body[0],
+      `import { ${key} } from 'react';\n`
+    );
+
+    return;
+  }
+
+  // Only default import from 'react' - add named imports section
+  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);
+
+  // Named imports section is present and current key is already imported - do nothing
+  if (alreadyImportedKeys.includes(key)) {
+    return;
+  }
+
+  // Named imports section is present and current key is not imported yet - add it to named imports section
+  yield fixer.insertTextAfter([...importNode.specifiers].pop(), `, ${key}`);
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = 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',
+      category: 'Layout & Formatting'
+    },
+    messages: {
+      illegalReactPropertyAccess:
+        'Illegal React property access: {{name}}. Use named import instead.'
+    }
+  },
+
+  create(context) {
+    return {
+      // Analyze TS types declarations
+      TSQualifiedName(node) {
+        // Do nothing to types that are ending with 'Event' as they will overlap with global event types otherwise
+        if (node.left.name !== 'React' || 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);
+          }
+        });
+      },
+
+      // Analyze expressions for React.* access
+      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);
+          }
+        });
+      }
+    };
+  }
+});

package/lib/rules/tss/class-naming.js

@@ -1,43 +1,43 @@
-const { getStyesObj, isCamelCase } = require('../../util/tss');
-
-module.exports = {
-  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) {
-            // Skip over computed properties for now.
-            // e.g. `{ [foo]: { ... } }`
-            return;
-          }
-
-          if (
-            property.type === 'ExperimentalSpreadProperty' ||
-            property.type === 'SpreadElement'
-          ) {
-            // Skip over object spread for now.
-            // e.g. `{ ...foo }`
-            return;
-          }
-
-          const className = property.key.value || property.key.name;
-          if (!isCamelCase(className)) {
-            context.report(
-              property,
-              `Class \`${className}\` must be camelCase in makeStyles.`
-            );
-          }
-        });
-      }
-    };
-  }
-};
+const { getStyesObj, isCamelCase } = require('../../util/tss');
+
+module.exports = {
+  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) {
+            // Skip over computed properties for now.
+            // e.g. `{ [foo]: { ... } }`
+            return;
+          }
+
+          if (
+            property.type === 'ExperimentalSpreadProperty' ||
+            property.type === 'SpreadElement'
+          ) {
+            // Skip over object spread for now.
+            // e.g. `{ ...foo }`
+            return;
+          }
+
+          const className = property.key.value || property.key.name;
+          if (!isCamelCase(className)) {
+            context.report(
+              property,
+              `Class \`${className}\` must be camelCase in makeStyles.`
+            );
+          }
+        });
+      }
+    };
+  }
+};

package/lib/rules/tss/no-color-value.js

@@ -1,58 +1,58 @@
-const { getStyesObj } = require('../../util/tss');
-
-module.exports = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Enforce the use of color variables instead of color codes within makeStyles'
-    }
-  },
-  create: function (context) {
-    const parserOptions = context.parserOptions;
-    if (!parserOptions || !parserOptions.project) {
-      return {};
-    }
-
-    return {
-      CallExpression(node) {
-        const stylesObj = getStyesObj(node);
-        if (!stylesObj) {
-          return;
-        }
-
-        // Check for color codes inside the stylesObj
-        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 makeStyles.'
-              });
-            }
-          }
-        }
-
-        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);
-      }
-    };
-  }
-};
+const { getStyesObj } = require('../../util/tss');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Enforce the use of color variables instead of color codes within makeStyles'
+    }
+  },
+  create: function (context) {
+    const parserOptions = context.parserOptions;
+    if (!parserOptions || !parserOptions.project) {
+      return {};
+    }
+
+    return {
+      CallExpression(node) {
+        const stylesObj = getStyesObj(node);
+        if (!stylesObj) {
+          return;
+        }
+
+        // Check for color codes inside the stylesObj
+        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 makeStyles.'
+              });
+            }
+          }
+        }
+
+        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);
+      }
+    };
+  }
+};

package/lib/rules/tss/unused-classes.js

@@ -1,108 +1,108 @@
-const { getBasicIdentifier, getStyesObj } = require('../../util/tss');
-
-module.exports = {
-  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) {
-            // Skip over computed properties for now.
-            // e.g. `{ [foo]: { ... } }`
-            return;
-          }
-
-          if (
-            property.type === 'ExperimentalSpreadProperty' ||
-            property.type === 'SpreadElement'
-          ) {
-            // Skip over object spread for now.
-            // e.g. `{ ...foo }`
-            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) {
-          // props['foo' + bar].baz
-          return;
-        }
-
-        if (classIdentifier !== 'classes') {
-          // props.foo.bar
-          return;
-        }
-
-        const { parent } = node;
-
-        if (parent.type !== 'MemberExpression') {
-          // foo.styles
-          return;
-        }
-
-        if (
-          node.object.object &&
-          node.object.object.type !== 'ThisExpression'
-        ) {
-          // foo.foo.styles
-          return;
-        }
-
-        const propsIdentifier = getBasicIdentifier(parent.object);
-        if (propsIdentifier && propsIdentifier !== 'props') {
-          return;
-        }
-        if (!propsIdentifier && parent.object.type !== 'MemberExpression') {
-          return;
-        }
-
-        if (parent.parent.type === 'MemberExpression') {
-          // this.props.props.styles
-          return;
-        }
-
-        const parentClassIdentifier = getBasicIdentifier(parent.property);
-        if (parentClassIdentifier) {
-          usedClasses[parentClassIdentifier] = true;
-        }
-      },
-      'Program:exit': () => {
-        // Now we know all of the defined classes and used classes, so we can
-        // see if there are any defined classes that are not used.
-        Object.keys(definedClasses).forEach(definedClassKey => {
-          if (!usedClasses[definedClassKey]) {
-            context.report(
-              definedClasses[definedClassKey],
-              `Class \`${definedClassKey}\` is unused`
-            );
-          }
-        });
-      }
-    };
-  }
-};
+const { getBasicIdentifier, getStyesObj } = require('../../util/tss');
+
+module.exports = {
+  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) {
+            // Skip over computed properties for now.
+            // e.g. `{ [foo]: { ... } }`
+            return;
+          }
+
+          if (
+            property.type === 'ExperimentalSpreadProperty' ||
+            property.type === 'SpreadElement'
+          ) {
+            // Skip over object spread for now.
+            // e.g. `{ ...foo }`
+            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) {
+          // props['foo' + bar].baz
+          return;
+        }
+
+        if (classIdentifier !== 'classes') {
+          // props.foo.bar
+          return;
+        }
+
+        const { parent } = node;
+
+        if (parent.type !== 'MemberExpression') {
+          // foo.styles
+          return;
+        }
+
+        if (
+          node.object.object &&
+          node.object.object.type !== 'ThisExpression'
+        ) {
+          // foo.foo.styles
+          return;
+        }
+
+        const propsIdentifier = getBasicIdentifier(parent.object);
+        if (propsIdentifier && propsIdentifier !== 'props') {
+          return;
+        }
+        if (!propsIdentifier && parent.object.type !== 'MemberExpression') {
+          return;
+        }
+
+        if (parent.parent.type === 'MemberExpression') {
+          // this.props.props.styles
+          return;
+        }
+
+        const parentClassIdentifier = getBasicIdentifier(parent.property);
+        if (parentClassIdentifier) {
+          usedClasses[parentClassIdentifier] = true;
+        }
+      },
+      'Program:exit': () => {
+        // Now we know all of the defined classes and used classes, so we can
+        // see if there are any defined classes that are not used.
+        Object.keys(definedClasses).forEach(definedClassKey => {
+          if (!usedClasses[definedClassKey]) {
+            context.report(
+              definedClasses[definedClassKey],
+              `Class \`${definedClassKey}\` is unused`
+            );
+          }
+        });
+      }
+    };
+  }
+};