@sgfe/empower-app-context 0.1.7

package/lib/rules/prefer-message-ids.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const utils = require('../utils');
+const { getStaticValue } = require('eslint-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'require using `messageId` instead of `message` or `desc` to report rule violations',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/prefer-message-ids.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      messagesMissing:
+        '`meta.messages` must contain at least one violation message.',
+      foundMessage:
+        'Use `messageId` instead of `message` (for violations) or `desc` (for suggestions).',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    let contextIdentifiers;
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      Program(ast) {
+        const scope = sourceCode.getScope?.(ast) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < v9.0.0
+        contextIdentifiers = utils.getContextIdentifiers(
+          sourceCode.scopeManager,
+          ast
+        );
+
+        const metaNode = ruleInfo.meta;
+        const messagesNode =
+          metaNode &&
+          metaNode.properties &&
+          metaNode.properties.find(
+            (p) => p.type === 'Property' && utils.getKeyName(p) === 'messages'
+          );
+
+        if (!messagesNode) {
+          context.report({
+            node: metaNode || ruleInfo.create,
+            messageId: 'messagesMissing',
+          });
+          return;
+        }
+
+        const staticValue = getStaticValue(messagesNode.value, scope);
+        if (!staticValue) {
+          return;
+        }
+
+        if (
+          typeof staticValue.value === 'object' &&
+          staticValue.value.constructor === Object &&
+          Object.keys(staticValue.value).length === 0
+        ) {
+          context.report({
+            node: messagesNode.value,
+            messageId: 'messagesMissing',
+          });
+        }
+      },
+      CallExpression(node) {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+          if (!reportInfo) {
+            return;
+          }
+
+          const reportMessagesAndDataArray = utils
+            .collectReportViolationAndSuggestionData(reportInfo)
+            .filter((obj) => obj.message);
+          for (const { message } of reportMessagesAndDataArray) {
+            context.report({
+              node: message.parent,
+              messageId: 'foundMessage',
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/prefer-object-rule.js

@@ -0,0 +1,83 @@
+/**
+ * @author Brad Zacher <https://github.com/bradzacher>
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'disallow function-style rules',
+      category: 'Rules',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/prefer-object-rule.md',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      preferObject: 'Rules should be declared using the object style.',
+    },
+  },
+
+  create(context) {
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    return {
+      Program() {
+        if (ruleInfo.isNewStyle) {
+          return;
+        }
+
+        context.report({
+          node: ruleInfo.create,
+          messageId: 'preferObject',
+          *fix(fixer) {
+            // note - we intentionally don't worry about formatting here, as otherwise we have
+            //        to indent the function correctly
+
+            if (
+              ruleInfo.create.type === 'FunctionExpression' ||
+              ruleInfo.create.type === 'FunctionDeclaration'
+            ) {
+              const openParenToken = sourceCode.getFirstToken(
+                ruleInfo.create,
+                (token) => token.type === 'Punctuator' && token.value === '('
+              );
+
+              /* istanbul ignore if */
+              if (!openParenToken) {
+                // this shouldn't happen, but guarding against crashes just in case
+                return null;
+              }
+
+              yield fixer.replaceTextRange(
+                [ruleInfo.create.range[0], openParenToken.range[0]],
+                '{create'
+              );
+              yield fixer.insertTextAfter(ruleInfo.create, '}');
+            } else if (ruleInfo.create.type === 'ArrowFunctionExpression') {
+              yield fixer.insertTextBefore(ruleInfo.create, '{create: ');
+              yield fixer.insertTextAfter(ruleInfo.create, '}');
+            }
+          },
+        });
+      },
+    };
+  },
+};

package/lib/rules/prefer-output-null.js

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview disallows invalid RuleTester test cases where the `output` matches the `code`
+ * @author 薛定谔的猫<hh_2013@foxmail.com>
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'disallow invalid RuleTester test cases where the `output` matches the `code`',
+      category: 'Tests',
+      recommended: true,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/prefer-output-null.md',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useOutputNull:
+        'Use `output: null` to assert that a test case is not autofixed.',
+    },
+  },
+
+  create(context) {
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+
+    return {
+      Program(ast) {
+        utils.getTestInfo(context, ast).forEach((testRun) => {
+          testRun.invalid.forEach((test) => {
+            /**
+             * Get a test case's giving keyname node.
+             * @param {string} the keyname to find.
+             * @returns {Node} found node; if not found, return null;
+             */
+            function getTestInfo(key) {
+              if (test.type === 'ObjectExpression') {
+                return test.properties.find(
+                  (item) => item.type === 'Property' && item.key.name === key
+                );
+              }
+              return null;
+            }
+
+            const code = getTestInfo('code');
+            const output = getTestInfo('output');
+
+            if (
+              output &&
+              sourceCode.getText(output.value) ===
+                sourceCode.getText(code.value)
+            ) {
+              context.report({
+                node: output,
+                messageId: 'useOutputNull',
+                fix: (fixer) => fixer.replaceText(output.value, 'null'),
+              });
+            }
+          });
+        });
+      },
+    };
+  },
+};

package/lib/rules/prefer-placeholders.js

@@ -0,0 +1,102 @@
+/**
+ * @fileoverview require using placeholders for dynamic report messages
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const utils = require('../utils');
+const { findVariable } = require('eslint-utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'require using placeholders for dynamic report messages',
+      category: 'Rules',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/prefer-placeholders.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      usePlaceholders:
+        'Use report message placeholders instead of string concatenation.',
+    },
+  },
+
+  create(context) {
+    let contextIdentifiers;
+
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const { scopeManager } = sourceCode;
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(scopeManager, ast);
+      },
+      CallExpression(node) {
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+
+          if (!reportInfo) {
+            return;
+          }
+
+          const reportMessagesAndDataArray = utils
+            .collectReportViolationAndSuggestionData(reportInfo)
+            .filter((obj) => obj.message);
+          for (let { message: messageNode } of reportMessagesAndDataArray) {
+            if (messageNode.type === 'Identifier') {
+              // See if we can find the variable declaration.
+
+              const variable = findVariable(
+                scopeManager.acquire(messageNode) || scopeManager.globalScope,
+                messageNode
+              );
+
+              if (
+                !variable ||
+                !variable.defs ||
+                !variable.defs[0] ||
+                !variable.defs[0].node ||
+                variable.defs[0].node.type !== 'VariableDeclarator' ||
+                !variable.defs[0].node.init
+              ) {
+                return;
+              }
+
+              messageNode = variable.defs[0].node.init;
+            }
+
+            if (
+              (messageNode.type === 'TemplateLiteral' &&
+                messageNode.expressions.length > 0) ||
+              (messageNode.type === 'BinaryExpression' &&
+                messageNode.operator === '+')
+            ) {
+              context.report({
+                node: messageNode,
+                messageId: 'usePlaceholders',
+              });
+            }
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/prefer-replace-text.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview prefer using `replaceText()` instead of `replaceTextRange()`
+ * @author 薛定谔的猫<hh_2013@foxmail.com>
+ */
+
+'use strict';
+
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'require using `replaceText()` instead of `replaceTextRange()`',
+      category: 'Rules',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/prefer-replace-text.md',
+    },
+    fixable: null,
+    schema: [],
+    messages: {
+      useReplaceText: 'Use replaceText instead of replaceTextRange.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    let funcInfo = {
+      upper: null,
+      codePath: null,
+      shouldCheck: false,
+      node: null,
+    };
+    let contextIdentifiers;
+
+    return {
+      Program(ast) {
+        contextIdentifiers = utils.getContextIdentifiers(
+          sourceCode.scopeManager,
+          ast
+        );
+      },
+
+      // Stacks this function's information.
+      onCodePathStart(codePath, node) {
+        funcInfo = {
+          upper: funcInfo,
+          codePath,
+          shouldCheck:
+            utils.isAutoFixerFunction(node, contextIdentifiers) ||
+            utils.isSuggestionFixerFunction(node, contextIdentifiers),
+          node,
+        };
+      },
+
+      // Pops this function's information.
+      onCodePathEnd() {
+        funcInfo = funcInfo.upper;
+      },
+
+      // Checks the replaceTextRange arguments.
+      'CallExpression[arguments.length=2]'(node) {
+        if (
+          funcInfo.shouldCheck &&
+          node.callee.type === 'MemberExpression' &&
+          node.callee.property.name === 'replaceTextRange'
+        ) {
+          const arg = node.arguments[0];
+          const isIdenticalNodeRange =
+            arg.type === 'ArrayExpression' &&
+            arg.elements[0].type === 'MemberExpression' &&
+            arg.elements[1].type === 'MemberExpression' &&
+            sourceCode.getText(arg.elements[0].object) ===
+              sourceCode.getText(arg.elements[1].object);
+          if (isIdenticalNodeRange) {
+            context.report({
+              node,
+              messageId: 'useReplaceText',
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/lib/rules/report-message-format.js

@@ -0,0 +1,133 @@
+/**
+ * @fileoverview enforce a consistent format for rule report messages
+ * @author Teddy Katz
+ */
+
+'use strict';
+
+const { getStaticValue } = require('eslint-utils');
+const utils = require('../utils');
+
+// ------------------------------------------------------------------------------
+// Rule Definition
+// ------------------------------------------------------------------------------
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'enforce a consistent format for rule report messages',
+      category: 'Rules',
+      recommended: false,
+      url: 'https://github.com/eslint-community/eslint-plugin-eslint-plugin/tree/HEAD/docs/rules/report-message-format.md',
+    },
+    fixable: null,
+    schema: [{ type: 'string' }],
+    messages: {
+      noMatch: "Report message does not match the pattern '{{pattern}}'.",
+    },
+  },
+
+  create(context) {
+    const pattern = new RegExp(context.options[0] || '');
+    let contextIdentifiers;
+
+    /**
+     * Report a message node if it doesn't match the given formatting
+     * @param {ASTNode} message The message AST node
+     * @returns {void}
+     */
+    function processMessageNode(message, scope) {
+      const staticValue = getStaticValue(message, scope);
+      if (
+        (message.type === 'Literal' &&
+          typeof message.value === 'string' &&
+          !pattern.test(message.value)) ||
+        (message.type === 'TemplateLiteral' &&
+          message.quasis.length === 1 &&
+          !pattern.test(message.quasis[0].value.cooked)) ||
+        (staticValue && !pattern.test(staticValue.value))
+      ) {
+        context.report({
+          node: message,
+          messageId: 'noMatch',
+          data: { pattern: context.options[0] || '' },
+        });
+      }
+    }
+
+    const sourceCode = context.sourceCode || context.getSourceCode(); // TODO: just use context.sourceCode when dropping eslint < v9
+    const ruleInfo = utils.getRuleInfo(sourceCode);
+    if (!ruleInfo) {
+      return {};
+    }
+
+    // ----------------------------------------------------------------------
+    // Public
+    // ----------------------------------------------------------------------
+
+    return {
+      Program(ast) {
+        const scope = sourceCode.getScope?.(ast) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < v9.0.0
+        contextIdentifiers = utils.getContextIdentifiers(
+          sourceCode.scopeManager,
+          ast
+        );
+
+        const messagesObject =
+          ruleInfo &&
+          ruleInfo.meta &&
+          ruleInfo.meta.type === 'ObjectExpression' &&
+          ruleInfo.meta.properties.find(
+            (prop) =>
+              prop.type === 'Property' && utils.getKeyName(prop) === 'messages'
+          );
+
+        if (
+          !messagesObject ||
+          messagesObject.value.type !== 'ObjectExpression'
+        ) {
+          return;
+        }
+
+        messagesObject.value.properties
+          .filter((prop) => prop.type === 'Property')
+          .map((prop) => prop.value)
+          .forEach((it) => processMessageNode(it, scope));
+      },
+      CallExpression(node) {
+        const scope = sourceCode.getScope?.(node) || context.getScope(); // TODO: just use sourceCode.getScope() when we drop support for ESLint < v9.0.0
+        if (
+          node.callee.type === 'MemberExpression' &&
+          contextIdentifiers.has(node.callee.object) &&
+          node.callee.property.type === 'Identifier' &&
+          node.callee.property.name === 'report'
+        ) {
+          const reportInfo = utils.getReportInfo(node, context);
+          const message = reportInfo && reportInfo.message;
+          const suggest = reportInfo && reportInfo.suggest;
+
+          if (message) {
+            processMessageNode(message, scope);
+          }
+
+          if (suggest && suggest.type === 'ArrayExpression') {
+            suggest.elements
+              .flatMap((obj) =>
+                obj.type === 'ObjectExpression' ? obj.properties : []
+              )
+              .filter(
+                (prop) =>
+                  prop.type === 'Property' &&
+                  prop.key.type === 'Identifier' &&
+                  prop.key.name === 'message'
+              )
+              .map((prop) => prop.value)
+              .forEach((it) => processMessageNode(it, scope));
+          }
+        }
+      },
+    };
+  },
+};