Add support for detecting hooks from all namespaces

Hooks can now be detected even when not used from the `React` namespace.

Author: Gelio

src/react-hooks-nesting-walker/is-hook-call.ts

@@ -1,17 +1,46 @@
-import { CallExpression } from 'typescript';
+import {
+ CallExpression,
+ isIdentifier,
+ isPropertyAccessExpression,
+ Expression,
+} from 'typescript';
 
 import { isHookIdentifier } from './is-hook-identifier';
-import { isReactApiExpression } from './is-react-api-expression';
+import {
+ RuleOptions,
+ detectHooksFromNonReactNamespaceOptionName,
+} from './options';
 
 /**
  * Tests if a `CallExpression` calls a React Hook
  * @see https://github.com/facebook/react/blob/master/packages/eslint-plugin-react-hooks/src/RulesOfHooks.js#L26
  */
-export function isHookCall({ expression }: CallExpression) {
- return isHookAccessExpression(expression);
+export function isHookCall(
+ { expression }: CallExpression,
+ ruleOptions: RuleOptions,
+) {
+ if (isIdentifier(expression) && isHookIdentifier(expression)) {
+ return true;
+ } else if (
+ isPropertyAccessExpression(expression) &&
+ isHookIdentifier(expression.name)
+ ) {
+ if (ruleOptions[detectHooksFromNonReactNamespaceOptionName]) {
+ return true;
+ }
+
+ /**
+ * The expression from which the property is accessed.
+ *
+ * @example for `React.useState`, this would be the `React` identifier
+ */
+ const sourceExpression = expression.expression;
+
+ return isReactIdentifier(sourceExpression);
+ }
+
+ return false;
 }
 
-/**
- * Tests for `useHook` or `React.useHook` calls
- */
-const isHookAccessExpression = isReactApiExpression(isHookIdentifier);
+const isReactIdentifier = (expression: Expression) =>
+ isIdentifier(expression) && expression.text === 'React';

src/react-hooks-nesting-walker/options.ts

@@ -0,0 +1,35 @@
+export const detectHooksFromNonReactNamespaceOptionName =
+ 'detect-hooks-from-non-react-namespace';
+
+export interface RuleOptions {
+ /**
+ * When set to `true`, violations will be reported for hooks from namespaces other than `React
+ * (e.g. `MyHooks.useHook` will be treated as a hook).
+ */
+ [detectHooksFromNonReactNamespaceOptionName]?: boolean;
+}
+
+const defaultRuleOptions: RuleOptions = {};
+
+export function parseRuleOptions(rawOptionsArray: unknown): RuleOptions {
+ if (!Array.isArray(rawOptionsArray)) {
+ return defaultRuleOptions;
+ }
+
+ const rawOptions: Record<string, unknown> | undefined = rawOptionsArray[0];
+ if (!rawOptions) {
+ return defaultRuleOptions;
+ }
+
+ let parsedOptions: RuleOptions = { ...defaultRuleOptions };
+
+ const detectHooksFromNonReactNamespaceOption =
+ rawOptions[detectHooksFromNonReactNamespaceOptionName];
+ if (typeof detectHooksFromNonReactNamespaceOption === 'boolean') {
+ parsedOptions[
+ detectHooksFromNonReactNamespaceOptionName
+ ] = detectHooksFromNonReactNamespaceOption;
+ }
+
+ return parsedOptions;
+}

src/react-hooks-nesting-walker/react-hooks-nesting-walker.ts

@@ -26,12 +26,15 @@ import { isReactComponentDecorator } from './is-react-component-decorator';
 import { findAncestorFunction } from './find-ancestor-function';
 import { FunctionNode, isFunctionNode } from './function-node';
 import { findClosestAncestorNode } from './find-closest-ancestor-node';
+import { parseRuleOptions } from './options';
 
 export class ReactHooksNestingWalker extends RuleWalker {
  private functionsWithReturnStatements = new Set<FunctionNode>();
 
+ private readonly ruleOptions = parseRuleOptions(this.getOptions());
+
  public visitCallExpression(node: CallExpression) {
- if (isHookCall(node)) {
+ if (isHookCall(node, this.ruleOptions)) {
  this.visitHookAncestor(node, node.parent);
  }