Update local function rules

Author: Rel1cx

.pkgs/configs/package.json

@@ -23,7 +23,7 @@
     "@stylistic/eslint-plugin": "^5.5.0",
     "eslint-plugin-de-morgan": "^2.0.0",
     "eslint-plugin-function": "^0.0.33",
-    "eslint-plugin-function-rule": "^0.0.7",
+    "eslint-plugin-function-rule": "^0.0.9",
     "eslint-plugin-jsdoc": "^61.1.12",
     "eslint-plugin-perfectionist": "^4.15.1",
     "eslint-plugin-regexp": "^2.10.0",

.pkgs/function-rules/index.ts

@@ -1 +1,2 @@
-export * from "./rules/nullishComparison";
+export * from "./rules/nullish-comparison";
+export * from "./rules/template-expression";

.pkgs/function-rules/package.json

@@ -20,6 +20,9 @@
     "lint:publish": "publint",
     "lint:ts": "tsc --noEmit"
   },
+  "dependencies": {
+    "eslint-plugin-function-rule": "^0.0.9"
+  },
   "devDependencies": {
     "eslint": "^9.39.1",
     "tsdown": "^0.16.1"

.pkgs/function-rules/rules/nullishComparison.ts renamed to .pkgs/function-rules/rules/nullish-comparison.ts

@@ -9,8 +9,8 @@ export interface nullishComparisonOptions {
 
 // TODO: Implement different enforce options
 export function nullishComparison(options?: nullishComparisonOptions) {
-  return (context: Rule.RuleContext): Rule.RuleListener => {
-    return defineRuleListener({
+  return (context: Rule.RuleContext) =>
+    defineRuleListener({
       BinaryExpression(node): void {
         if (node.operator === "===" || node.operator === "!==") {
           const offendingChild = [node.left, node.right].find(
@@ -65,5 +65,4 @@ export function nullishComparison(options?: nullishComparisonOptions) {
         }
       },
     });
-  };
 }

.pkgs/function-rules/rules/template-expression.ts

@@ -0,0 +1,21 @@
+import type { Rule } from "eslint";
+import { defineRuleListener } from "eslint-plugin-function-rule";
+
+export interface templateExpressionOptions {
+  allowMultiline: boolean;
+}
+
+export function templateExpression(options?: templateExpressionOptions) {
+  const allowMultiline = options?.allowMultiline ?? false;
+  return (context: Rule.RuleContext) =>
+    defineRuleListener({
+      TemplateLiteral(node) {
+        if (!allowMultiline && node.loc?.start.line !== node.loc?.end.line) {
+          context.report({
+            node,
+            message: "Avoid multiline template expressions.",
+          });
+        }
+      },
+    });
+}

eslint.config.ts

@@ -11,9 +11,9 @@ import {
   disableTypeChecked,
   strictTypeChecked,
 } from "@local/configs/eslint";
-import { nullishComparison } from "@local/function-rules";
+import { nullishComparison, templateExpression } from "@local/function-rules";
 import { recommended as fastImportRecommended } from "eslint-plugin-fast-import";
-import functionRule from "eslint-plugin-function-rule";
+import { functionRule } from "eslint-plugin-function-rule";
 import pluginVitest from "eslint-plugin-vitest";
 import { defineConfig, globalIgnores } from "eslint/config";
 import tseslint from "typescript-eslint";
@@ -26,8 +26,6 @@ const packagesTsConfigs = [
   "packages/*/*/tsconfig.json",
 ];
 
-const nullishComparisonRule = nullishComparison();
-
 export default defineConfig([
   includeIgnoreFile(gitignore, "Imported .gitignore patterns") as never,
   globalIgnores([
@@ -55,21 +53,23 @@ export default defineConfig([
       },
     },
     plugins: {
-      "function-rule": functionRule((context) => ({
-        ...nullishComparisonRule(context),
-        TemplateLiteral(node) {
-          if (node.loc?.start.line !== node.loc?.end.line) {
-            context.report({
-              node,
-              message: "Avoid multiline template expressions.",
-            });
-          }
-        },
-      })),
+      "nullish-comparison": functionRule("v1", nullishComparison()),
+      "template-expression": functionRule("v1", templateExpression()),
+      // "template-expression": functionRule("v1", (context) => ({
+      //   TemplateLiteral(node) {
+      //     if (node.loc?.start.line !== node.loc?.end.line) {
+      //       context.report({
+      //         node,
+      //         message: "Avoid multiline template expressions.",
+      //       });
+      //     }
+      //   },
+      // })),
     },
     rules: {
       "fast-import/no-unused-exports": "off",
-      "function-rule/function-rule": "error",
+      "nullish-comparison/v1": "error",
+      "template-expression/v1": "warn",
     },
   },
   {
@@ -107,7 +107,8 @@ export default defineConfig([
     },
     rules: {
       "@typescript-eslint/no-empty-function": ["error", { allow: ["arrowFunctions"] }],
-      "function-rule/function-rule": "off",
+      "nullish-comparison/v1": "off",
+      "template-expression/v1": "off",
     },
   },
   disableProblematicEslintJsRules,

package.json

@@ -74,7 +74,7 @@
     "effect": "^3.19.3",
     "eslint": "^9.39.1",
     "eslint-plugin-fast-import": "^1.5.3",
-    "eslint-plugin-function-rule": "^0.0.7",
+    "eslint-plugin-function-rule": "^0.0.9",
     "eslint-plugin-vitest": "^0.5.4",
     "mdxlint": "^1.0.0",
     "publint": "^0.3.15",
@@ -111,7 +111,7 @@
       "@eslint/js": "9.39.1",
       "@types/react": "^19.2.2",
       "@types/react-dom": "^19.2.2",
-      "esbuild": "^0.26.0",
+      "esbuild": "^0.27.0",
       "eslint": "9.39.1",
       "fumadocs-core": "15.8.5",
       "fumadocs-docgen": "3.0.2",

packages/plugins/eslint-plugin-react-x/src/rules/jsx-shorthand-boolean.ts

@@ -75,7 +75,7 @@ export function create(context: RuleContext<MessageID, Options>): RuleListener {
         }
         // Enforce explicit `={true}` for boolean attributes (e.g., `prop={true}` instead of `prop`)
         case policy === -1
-          // eslint-disable-next-line function-rule/function-rule
+          // eslint-disable-next-line nullish-comparison/v1
           && value === null: {
           context.report({
             messageId: "jsxShorthandBoolean",

packages/utilities/ast/src/literal.ts

@@ -21,7 +21,7 @@ export function isLiteral(node: TSESTree.Node, type?: LiteralType) {
     case "boolean":
       return typeof node.value === "boolean";
     case "null":
-      // eslint-disable-next-line function-rule/function-rule
+      // eslint-disable-next-line nullish-comparison/v1
       return node.value === null;
     case "number":
       return typeof node.value === "number";

packages/utilities/ast/src/node-format.ts

@@ -6,7 +6,7 @@ import { delimiterCase, replace, toLowerCase } from "string-ts";
 import { isJSX } from "./node-is";
 
 function getLiteralValueType(input: bigint | boolean | null | number | string | symbol) {
-  // eslint-disable-next-line function-rule/function-rule
+  // eslint-disable-next-line nullish-comparison/v1
   if (input === null) return "null";
   return typeof input;
 }