eslint-plugin-rxjs-x 0.0.2 → 0.1.0

package/dist/index.cjs

@@ -2,10 +2,9 @@
 
 const utils = require('@typescript-eslint/utils');
 const commonTags = require('common-tags');
-const tsutils = require('tsutils-etc');
+const tsutils = require('ts-api-utils');
 const ts = require('typescript');
 const scopeManager = require('@typescript-eslint/scope-manager');
-const tsutils$1 = require('tsutils');
 const decamelize = require('decamelize');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -24,11 +23,10 @@ function _interopNamespaceCompat(e) {
 
 const tsutils__namespace = /*#__PURE__*/_interopNamespaceCompat(tsutils);
 const ts__namespace = /*#__PURE__*/_interopNamespaceCompat(ts);
-const tsutils__namespace$1 = /*#__PURE__*/_interopNamespaceCompat(tsutils$1);
 const decamelize__default = /*#__PURE__*/_interopDefaultCompat(decamelize);
 
 const name = "eslint-plugin-rxjs-x";
-const version = "0.0.2";
+const version = "0.1.0";
 
 const createRecommendedConfig = (plugin) => ({
   plugins: {
@@ -200,6 +198,75 @@ const banOperatorsRule = ruleCreator({
   }
 });
 
+function couldBeType(type, name, qualified) {
+  if (tsutils__namespace.isTypeReference(type)) {
+    type = type.target;
+  }
+  if (isType(type, name, qualified)) {
+    return true;
+  }
+  if (tsutils__namespace.isUnionOrIntersectionType(type)) {
+    return type.types.some((t) => couldBeType(t, name, qualified));
+  }
+  const baseTypes = type.getBaseTypes();
+  if (baseTypes?.some((t) => couldBeType(t, name, qualified))) {
+    return true;
+  }
+  if (couldImplement(type, name, qualified)) {
+    return true;
+  }
+  return false;
+}
+function isType(type, name, qualified) {
+  if (!type.symbol) {
+    return false;
+  }
+  if (qualified && !qualified.name.test(
+    qualified.typeChecker.getFullyQualifiedName(type.symbol)
+  )) {
+    return false;
+  }
+  return typeof name === "string" ? type.symbol.name === name : Boolean(type.symbol.name.match(name));
+}
+function couldImplement(type, name, qualified) {
+  const { symbol } = type;
+  if (symbol) {
+    const { valueDeclaration } = symbol;
+    if (valueDeclaration && ts__namespace.isClassDeclaration(valueDeclaration)) {
+      const { heritageClauses } = valueDeclaration;
+      if (heritageClauses) {
+        const implemented = heritageClauses.some(
+          ({ token, types }) => token === ts__namespace.SyntaxKind.ImplementsKeyword && types.some((node) => isMatchingNode(node, name, qualified))
+        );
+        if (implemented) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isMatchingNode(node, name, qualified) {
+  const { expression } = node;
+  if (qualified) {
+    const type = qualified.typeChecker.getTypeAtLocation(expression);
+    if (type) {
+      const qualifiedName = qualified.typeChecker.getFullyQualifiedName(
+        type.symbol
+      );
+      if (!qualified.name.test(qualifiedName)) {
+        return false;
+      }
+    }
+  }
+  const text = expression.getText();
+  return typeof name === "string" ? text === name : Boolean(text.match(name));
+}
+
+function couldBeFunction(type) {
+  return type.getCallSignatures().length > 0 || couldBeType(type, "Function") || couldBeType(type, "ArrowFunction") || couldBeType(type, ts__namespace.InternalSymbolName.Function);
+}
+
 function findParent(node, ...args) {
   const [arg] = args;
   const predicate = typeof arg === "function" ? arg : (type) => !args.includes(type) ? "continue" : "return";
@@ -282,9 +349,9 @@ function getTypeServices(context) {
   const services = utils.ESLintUtils.getParserServices(context);
   const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
-  const couldBeType = (node, name, qualified) => {
+  const couldBeType$1 = (node, name, qualified) => {
     const type = getType(node);
-    return tsutils__namespace.couldBeType(
+    return couldBeType(
       type,
       name,
       qualified ? { ...qualified, typeChecker } : void 0
@@ -299,7 +366,7 @@ function getTypeServices(context) {
       tsTypeNode = tsNode.type;
     }
     return Boolean(
-      tsTypeNode && tsutils__namespace.couldBeType(
+      tsTypeNode && couldBeType(
         typeChecker.getTypeAtLocation(tsTypeNode),
         name,
         qualified ? { ...qualified, typeChecker } : void 0
@@ -310,25 +377,25 @@ function getTypeServices(context) {
     return getTypeAtLocation(node);
   };
   return {
-    couldBeBehaviorSubject: (node) => couldBeType(node, "BehaviorSubject"),
-    couldBeError: (node) => couldBeType(node, "Error"),
+    couldBeBehaviorSubject: (node) => couldBeType$1(node, "BehaviorSubject"),
+    couldBeError: (node) => couldBeType$1(node, "Error"),
     couldBeFunction: (node) => {
       if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
         return true;
       }
-      return tsutils__namespace.couldBeFunction(getType(node));
+      return couldBeFunction(getType(node));
     },
-    couldBeMonoTypeOperatorFunction: (node) => couldBeType(node, "MonoTypeOperatorFunction"),
-    couldBeObservable: (node) => couldBeType(node, "Observable"),
-    couldBeSubject: (node) => couldBeType(node, "Subject"),
-    couldBeSubscription: (node) => couldBeType(node, "Subscription"),
-    couldBeType,
+    couldBeMonoTypeOperatorFunction: (node) => couldBeType$1(node, "MonoTypeOperatorFunction"),
+    couldBeObservable: (node) => couldBeType$1(node, "Observable"),
+    couldBeSubject: (node) => couldBeType$1(node, "Subject"),
+    couldBeSubscription: (node) => couldBeType$1(node, "Subscription"),
+    couldBeType: couldBeType$1,
     couldReturnObservable: (node) => couldReturnType(node, "Observable"),
     couldReturnType,
     getType,
-    isAny: (node) => tsutils__namespace.isAny(getType(node)),
-    isReferenceType: (node) => tsutils__namespace.isReferenceType(getType(node)),
-    isUnknown: (node) => tsutils__namespace.isUnknown(getType(node)),
+    isAny: (node) => tsutils__namespace.isIntrinsicAnyType(getType(node)),
+    isReferenceType: (node) => tsutils__namespace.isTypeReference(getType(node)),
+    isUnknown: (node) => tsutils__namespace.isIntrinsicUnknownType(getType(node)),
     typeChecker
   };
 }
@@ -2288,19 +2355,19 @@ const noUnsafeSubjectNext = ruleCreator({
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
           const type = getType(node.callee.object);
-          if (tsutils.isReferenceType(type) && tsutils.couldBeType(type, "Subject")) {
+          if (tsutils__namespace.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Any)) {
+            if (tsutils__namespace.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Any)) {
               return;
             }
-            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Unknown)) {
+            if (tsutils__namespace.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils__namespace$1.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Void)) {
+            if (tsutils__namespace.isTypeFlagSet(typeArg, ts__namespace.TypeFlags.Void)) {
               return;
             }
-            if (tsutils.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils__namespace$1.isTypeFlagSet(t, ts__namespace.TypeFlags.Void)
+            if (tsutils__namespace.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils__namespace.isTypeFlagSet(t, ts__namespace.TypeFlags.Void)
             )) {
               return;
             }
@@ -2852,13 +2919,13 @@ const throwErrorRule = ruleCreator({
     const { couldBeObservable, getType } = getTypeServices(context);
     function checkNode(node) {
       let type = getType(node);
-      if (tsutils.couldBeFunction(type)) {
+      if (couldBeFunction(type)) {
         const tsNode = esTreeNodeToTSNodeMap.get(node);
         const annotation = tsNode.type;
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation ?? body);
       }
-      if (!tsutils.isAny(type) && !tsutils.isUnknown(type) && !tsutils.couldBeType(type, /^(Error|DOMException)$/)) {
+      if (!tsutils__namespace.isIntrinsicAnyType(type) && !tsutils__namespace.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
         context.report({
           messageId: "forbidden",
           node

package/dist/index.mjs

@@ -1,14 +1,12 @@
 import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
 import { stripIndent } from 'common-tags';
-import * as tsutils from 'tsutils-etc';
-import { isReferenceType, couldBeType, isUnionType, couldBeFunction, isAny, isUnknown } from 'tsutils-etc';
+import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 import { DefinitionType } from '@typescript-eslint/scope-manager';
-import * as tsutils$1 from 'tsutils';
 import decamelize from 'decamelize';
 
 const name = "eslint-plugin-rxjs-x";
-const version = "0.0.2";
+const version = "0.1.0";
 
 const createRecommendedConfig = (plugin) => ({
   plugins: {
@@ -180,6 +178,75 @@ const banOperatorsRule = ruleCreator({
   }
 });
 
+function couldBeType(type, name, qualified) {
+  if (tsutils.isTypeReference(type)) {
+    type = type.target;
+  }
+  if (isType(type, name, qualified)) {
+    return true;
+  }
+  if (tsutils.isUnionOrIntersectionType(type)) {
+    return type.types.some((t) => couldBeType(t, name, qualified));
+  }
+  const baseTypes = type.getBaseTypes();
+  if (baseTypes?.some((t) => couldBeType(t, name, qualified))) {
+    return true;
+  }
+  if (couldImplement(type, name, qualified)) {
+    return true;
+  }
+  return false;
+}
+function isType(type, name, qualified) {
+  if (!type.symbol) {
+    return false;
+  }
+  if (qualified && !qualified.name.test(
+    qualified.typeChecker.getFullyQualifiedName(type.symbol)
+  )) {
+    return false;
+  }
+  return typeof name === "string" ? type.symbol.name === name : Boolean(type.symbol.name.match(name));
+}
+function couldImplement(type, name, qualified) {
+  const { symbol } = type;
+  if (symbol) {
+    const { valueDeclaration } = symbol;
+    if (valueDeclaration && ts.isClassDeclaration(valueDeclaration)) {
+      const { heritageClauses } = valueDeclaration;
+      if (heritageClauses) {
+        const implemented = heritageClauses.some(
+          ({ token, types }) => token === ts.SyntaxKind.ImplementsKeyword && types.some((node) => isMatchingNode(node, name, qualified))
+        );
+        if (implemented) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+function isMatchingNode(node, name, qualified) {
+  const { expression } = node;
+  if (qualified) {
+    const type = qualified.typeChecker.getTypeAtLocation(expression);
+    if (type) {
+      const qualifiedName = qualified.typeChecker.getFullyQualifiedName(
+        type.symbol
+      );
+      if (!qualified.name.test(qualifiedName)) {
+        return false;
+      }
+    }
+  }
+  const text = expression.getText();
+  return typeof name === "string" ? text === name : Boolean(text.match(name));
+}
+
+function couldBeFunction(type) {
+  return type.getCallSignatures().length > 0 || couldBeType(type, "Function") || couldBeType(type, "ArrowFunction") || couldBeType(type, ts.InternalSymbolName.Function);
+}
+
 function findParent(node, ...args) {
   const [arg] = args;
   const predicate = typeof arg === "function" ? arg : (type) => !args.includes(type) ? "continue" : "return";
@@ -262,9 +329,9 @@ function getTypeServices(context) {
   const services = ESLintUtils.getParserServices(context);
   const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
-  const couldBeType = (node, name, qualified) => {
+  const couldBeType$1 = (node, name, qualified) => {
     const type = getType(node);
-    return tsutils.couldBeType(
+    return couldBeType(
       type,
       name,
       qualified ? { ...qualified, typeChecker } : void 0
@@ -279,7 +346,7 @@ function getTypeServices(context) {
       tsTypeNode = tsNode.type;
     }
     return Boolean(
-      tsTypeNode && tsutils.couldBeType(
+      tsTypeNode && couldBeType(
         typeChecker.getTypeAtLocation(tsTypeNode),
         name,
         qualified ? { ...qualified, typeChecker } : void 0
@@ -290,25 +357,25 @@ function getTypeServices(context) {
     return getTypeAtLocation(node);
   };
   return {
-    couldBeBehaviorSubject: (node) => couldBeType(node, "BehaviorSubject"),
-    couldBeError: (node) => couldBeType(node, "Error"),
+    couldBeBehaviorSubject: (node) => couldBeType$1(node, "BehaviorSubject"),
+    couldBeError: (node) => couldBeType$1(node, "Error"),
     couldBeFunction: (node) => {
       if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
         return true;
       }
-      return tsutils.couldBeFunction(getType(node));
+      return couldBeFunction(getType(node));
     },
-    couldBeMonoTypeOperatorFunction: (node) => couldBeType(node, "MonoTypeOperatorFunction"),
-    couldBeObservable: (node) => couldBeType(node, "Observable"),
-    couldBeSubject: (node) => couldBeType(node, "Subject"),
-    couldBeSubscription: (node) => couldBeType(node, "Subscription"),
-    couldBeType,
+    couldBeMonoTypeOperatorFunction: (node) => couldBeType$1(node, "MonoTypeOperatorFunction"),
+    couldBeObservable: (node) => couldBeType$1(node, "Observable"),
+    couldBeSubject: (node) => couldBeType$1(node, "Subject"),
+    couldBeSubscription: (node) => couldBeType$1(node, "Subscription"),
+    couldBeType: couldBeType$1,
     couldReturnObservable: (node) => couldReturnType(node, "Observable"),
     couldReturnType,
     getType,
-    isAny: (node) => tsutils.isAny(getType(node)),
-    isReferenceType: (node) => tsutils.isReferenceType(getType(node)),
-    isUnknown: (node) => tsutils.isUnknown(getType(node)),
+    isAny: (node) => tsutils.isIntrinsicAnyType(getType(node)),
+    isReferenceType: (node) => tsutils.isTypeReference(getType(node)),
+    isUnknown: (node) => tsutils.isIntrinsicUnknownType(getType(node)),
     typeChecker
   };
 }
@@ -2268,19 +2335,19 @@ const noUnsafeSubjectNext = ruleCreator({
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
           const type = getType(node.callee.object);
-          if (isReferenceType(type) && couldBeType(type, "Subject")) {
+          if (tsutils.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils$1.isTypeFlagSet(typeArg, ts.TypeFlags.Any)) {
+            if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Any)) {
               return;
             }
-            if (tsutils$1.isTypeFlagSet(typeArg, ts.TypeFlags.Unknown)) {
+            if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils$1.isTypeFlagSet(typeArg, ts.TypeFlags.Void)) {
+            if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Void)) {
               return;
             }
-            if (isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils$1.isTypeFlagSet(t, ts.TypeFlags.Void)
+            if (tsutils.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils.isTypeFlagSet(t, ts.TypeFlags.Void)
             )) {
               return;
             }
@@ -2838,7 +2905,7 @@ const throwErrorRule = ruleCreator({
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation ?? body);
       }
-      if (!isAny(type) && !isUnknown(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
+      if (!tsutils.isIntrinsicAnyType(type) && !tsutils.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
         context.report({
           messageId: "forbidden",
           node

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-rxjs-x",
   "type": "module",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "packageManager": "yarn@4.5.1+sha512.341db9396b6e289fecc30cd7ab3af65060e05ebff4b3b47547b278b9e67b08f485ecd8c79006b405446262142c7a38154445ef7f17c1d5d1de7d90bf9ce7054d",
   "description": "ESLint v9+ plugin for RxJS",
   "author": "Jason Weinzierl <weinzierljason@gmail.com>",
@@ -53,14 +53,13 @@
     "@typescript-eslint/utils": "^8.12.2",
     "common-tags": "^1.8.0",
     "decamelize": "^5.0.0 || ^6.0.0",
-    "tslib": "^2.0.0",
-    "tsutils": "^3.0.0",
-    "tsutils-etc": "^1.4.2"
+    "ts-api-utils": "^1.3.0",
+    "tslib": "^2.1.0"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0",
     "rxjs": ">=7.0.0",
-    "typescript": ">=4.0.0"
+    "typescript": ">=4.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.13.0",
@@ -68,7 +67,9 @@
     "@types/common-tags": "^1.8.4",
     "@types/node": "^18.18.0",
     "@typescript-eslint/rule-tester": "^8.12.2",
+    "@typescript/vfs": "^1.6.0",
     "@vitest/coverage-v8": "^2.1.4",
+    "@vitest/eslint-plugin": "^1.1.7",
     "bumpp": "^9.8.0",
     "eslint": "^9.13.0",
     "eslint-config-flat-gitignore": "^0.3.0",