feat(perfer-tacit): allow specifying which type need binds

README.md

@@ -108,7 +108,7 @@ The [below section](#rules) gives details on which rules are enabled by each rul
 
 | Name                                                         | Description                    | 💼                          | ⚠️ | 🚫 | 🔧 | 💡 | 💭 | ❌  |
 | :----------------------------------------------------------- | :----------------------------- | :-------------------------- | :- | :- | :- | :- | :- | :- |
-| [functional-parameters](docs/rules/functional-parameters.md) | Enforce functional parameters. | ☑️ ✅ 🔒 ![badge-currying][] |    |    |    |    |    |    |
+| [functional-parameters](docs/rules/functional-parameters.md) | Enforce functional parameters. | ☑️ ✅ 🔒 ![badge-currying][] |    |    |    |    | 💭 |    |
 
 ### No Exceptions
 

docs/rules/functional-parameters.md

@@ -2,10 +2,14 @@
 
 💼 This rule is enabled in the following configs: `currying`, ☑️ `lite`, ✅ `recommended`, 🔒 `strict`.
 
+💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
+
 <!-- end auto-generated rule header -->
 
 Disallow use of rest parameters, the `arguments` keyword and enforces that functions take at least 1 parameter.
 
+Note: type information is only required when using the [overrides](#overrides) option.
+
 ## Rule Details
 
 In functions, `arguments` is a special variable that is implicitly available.
@@ -67,6 +71,23 @@ type Options = {
       };
   ignoreIdentifierPattern?: string[] | string;
   ignorePrefixSelector?: string[] | string;
+  overrides?: Array<{
+    match:
+      | {
+          from: "file";
+          path?: string;
+        }
+      | {
+          from: "lib";
+        }
+      | {
+          from: "package";
+          package?: string;
+        }
+      | TypeDeclarationSpecifier[];
+    options: Omit<Options, "overrides">;
+    disable: boolean;
+  }>;
 };
 ```
 
@@ -196,3 +217,24 @@ const sum = [1, 2, 3].reduce((carry, current) => current, 0);
 
 This option takes a RegExp string or an array of RegExp strings.
 It allows for the ability to ignore violations based on a function's name.
+
+### `overrides`
+
+_Using this option requires type infomation._
+
+Allows for applying overrides to the options based on where the function's type is defined.
+This can be used to override the settings for types coming from 3rd party libraries.
+
+Note: Only the first matching override will be used.
+
+#### `overrides[n].specifiers`
+
+A specifier, or an array of specifiers to match the function type against.
+
+#### `overrides[n].options`
+
+The options to use when a specifiers matches.
+
+#### `overrides[n].disable`
+
+If true, when a specifier matches, this rule will not be applied to the matching node.

docs/rules/prefer-immutable-types.md

@@ -244,6 +244,24 @@ type Options = {
     ReadonlyDeep?: Array<Array<{ pattern: string; replace: string }>>;
     Immutable?: Array<Array<{ pattern: string; replace: string }>>;
   };
+
+  overrides?: Array<{
+    match:
+      | {
+          from: "file";
+          path?: string;
+        }
+      | {
+          from: "lib";
+        }
+      | {
+          from: "package";
+          package?: string;
+        }
+      | TypeDeclarationSpecifier[];
+    options: Omit<Options, "overrides">;
+    disable: boolean;
+  }>;
 };
 ```
 
@@ -475,3 +493,22 @@ It allows for the ability to ignore violations based on the identifier (name) of
 
 This option takes a `RegExp` string or an array of `RegExp` strings.
 It allows for the ability to ignore violations based on the type (as written, with whitespace removed) of the node in question.
+
+### `overrides`
+
+Allows for applying overrides to the options based on where the type is defined.
+This can be used to override the settings for types coming from 3rd party libraries.
+
+Note: Only the first matching override will be used.
+
+#### `overrides[n].specifiers`
+
+A specifier, or an array of specifiers to match the function type against.
+
+#### `overrides[n].options`
+
+The options to use when a specifiers matches.
+
+#### `overrides[n].disable`
+
+If true, when a specifier matches, this rule will not be applied to the matching node.

package.json

@@ -95,7 +95,8 @@
     "escape-string-regexp": "^4.0.0",
     "is-immutable-type": "^3.1.0",
     "semver": "^7.6.0",
-    "ts-api-utils": "^1.3.0"
+    "ts-api-utils": "^1.3.0",
+    "ts-declaration-location": "1.0.0"
   },
   "devDependencies": {
     "@babel/eslint-parser": "7.24.1",

src/options/index.ts

@@ -1 +1,2 @@
 export * from "./ignore";
+export * from "./overrides";

src/options/overrides.ts

@@ -0,0 +1,68 @@
+import { type TSESTree } from "@typescript-eslint/utils";
+import { type RuleContext } from "@typescript-eslint/utils/ts-eslint";
+import typeMatchesSpecifier, {
+  type TypeDeclarationSpecifier,
+} from "ts-declaration-location";
+
+import { getTypeOfNode } from "../utils/rule";
+
+/**
+ * Options that can be overridden.
+ */
+export type OverridableOptions<CoreOptions> = CoreOptions & {
+  overrides?: Array<
+    {
+      specifiers: TypeDeclarationSpecifier | TypeDeclarationSpecifier[];
+    } & (
+      | {
+          options: CoreOptions;
+          disable?: false;
+        }
+      | {
+          disable: true;
+        }
+    )
+  >;
+};
+
+/**
+ * Get the core options to use, taking into account overrides.
+ *
+ * @throws when there is a configuration error.
+ */
+export function getCoreOptions<
+  CoreOptions extends object,
+  Options extends readonly [Readonly<OverridableOptions<CoreOptions>>],
+>(
+  node: TSESTree.Node,
+  context: Readonly<RuleContext<string, Options>>,
+  options: Readonly<Options>,
+): CoreOptions | null {
+  const [optionsObject] = options;
+
+  const program = context.sourceCode.parserServices?.program ?? undefined;
+  if (program === undefined) {
+    return optionsObject;
+  }
+
+  const type = getTypeOfNode(node, context);
+  const found = optionsObject.overrides?.find((override) =>
+    (Array.isArray(override.specifiers)
+      ? override.specifiers
+      : [override.specifiers]
+    ).some((specifier) => typeMatchesSpecifier(program, specifier, type)),
+  );
+
+  if (found !== undefined) {
+    if (found.disable === true) {
+      return null;
+    }
+    if (found.options === undefined) {
+      // eslint-disable-next-line functional/no-throw-statements
+      throw new Error("Configuration error: No options found for override.");
+    }
+    return found.options;
+  }
+
+  return optionsObject;
+}