eslint-plugin-rxjs-x 0.2.4 → 0.3.1

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "0.2.4";
+var version = "0.3.1";
 
 // src/configs/recommended.ts
 var createRecommendedConfig = (plugin2) => ({
@@ -119,78 +119,11 @@ var banObservablesRule = ruleCreator({
 // src/rules/ban-operators.ts
 
 
-var defaultOptions2 = [];
-var banOperatorsRule = ruleCreator({
-  defaultOptions: defaultOptions2,
-  meta: {
-    docs: {
-      description: "Disallow banned operators."
-    },
-    messages: {
-      forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
-    },
-    schema: [
-      {
-        type: "object",
-        description: _commontags.stripIndent`
-          An object containing keys that are names of operators
-          and values that are either booleans or strings containing the explanation for the ban.`
-      }
-    ],
-    type: "problem"
-  },
-  name: "ban-operators",
-  create: (context) => {
-    const bans = [];
-    const [config] = context.options;
-    if (!config) {
-      return {};
-    }
-    Object.entries(config).forEach(([key, value]) => {
-      if (value !== false) {
-        bans.push({
-          explanation: typeof value === "string" ? value : "",
-          regExp: new RegExp(`^${key}$`)
-        });
-      }
-    });
-    function getFailure(name2) {
-      for (let b = 0, length = bans.length; b < length; ++b) {
-        const ban = bans[b];
-        if (ban.regExp.test(name2)) {
-          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
-          return {
-            messageId: "forbidden",
-            data: { name: name2, explanation }
-          };
-        }
-      }
-      return void 0;
-    }
-    return {
-      [String.raw`ImportDeclaration[source.value=/^rxjs\u002foperators$/] > ImportSpecifier`]: (node) => {
-        const identifier = node.imported;
-        const name2 = identifier.type === _utils.AST_NODE_TYPES.Identifier ? identifier.name : identifier.value;
-        const failure = getFailure(name2);
-        if (failure) {
-          context.report({
-            ...failure,
-            node: identifier
-          });
-        }
-      }
-    };
-  }
-});
-
-// src/rules/finnish.ts
-
-
 // src/etc/could-be-function.ts
 var _typescript = require('typescript'); var _typescript2 = _interopRequireDefault(_typescript);
 
 // src/etc/could-be-type.ts
-var _tsapiutils = require('ts-api-utils'); var tsutils = _interopRequireWildcard(_tsapiutils); var tsutils2 = _interopRequireWildcard(_tsapiutils); var tsutils3 = _interopRequireWildcard(_tsapiutils); var tsutils4 = _interopRequireWildcard(_tsapiutils);
+var _tsapiutils = require('ts-api-utils'); var tsutils = _interopRequireWildcard(_tsapiutils); var tsutils2 = _interopRequireWildcard(_tsapiutils); var tsutils3 = _interopRequireWildcard(_tsapiutils);
 
 function couldBeType(type, name2, qualified) {
   if (tsutils.isTypeReference(type)) {
@@ -303,7 +236,6 @@ function getLoc(node) {
 
 
 
-
 // src/etc/is.ts
 
 function hasTypeAnnotation(node) {
@@ -358,7 +290,7 @@ function getTypeServices(context) {
   const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = services;
   const typeChecker = program.getTypeChecker();
   const couldBeType2 = (node, name2, qualified) => {
-    const type = getType(node);
+    const type = getTypeAtLocation(node);
     return couldBeType(
       type,
       name2,
@@ -382,17 +314,13 @@ function getTypeServices(context) {
       )
     );
   };
-  const getType = (node) => {
-    return getTypeAtLocation(node);
-  };
   return {
     couldBeBehaviorSubject: (node) => couldBeType2(node, "BehaviorSubject"),
-    couldBeError: (node) => couldBeType2(node, "Error"),
     couldBeFunction: (node) => {
       if (isArrowFunctionExpression(node) || isFunctionDeclaration(node)) {
         return true;
       }
-      return couldBeFunction(getType(node));
+      return couldBeFunction(getTypeAtLocation(node));
     },
     couldBeMonoTypeOperatorFunction: (node) => couldBeType2(node, "MonoTypeOperatorFunction"),
     couldBeObservable: (node) => couldBeType2(node, "Observable"),
@@ -400,12 +328,7 @@ function getTypeServices(context) {
     couldBeSubscription: (node) => couldBeType2(node, "Subscription"),
     couldBeType: couldBeType2,
     couldReturnObservable: (node) => couldReturnType(node, "Observable"),
-    couldReturnType,
-    getType,
-    isAny: (node) => tsutils2.isIntrinsicAnyType(getType(node)),
-    isReferenceType: (node) => tsutils2.isTypeReference(getType(node)),
-    isUnknown: (node) => tsutils2.isIntrinsicUnknownType(getType(node)),
-    typeChecker
+    couldReturnType
   };
 }
 
@@ -422,7 +345,71 @@ function isImport(scope, name2, source) {
   return scope.upper ? isImport(scope.upper, name2, source) : false;
 }
 
+// src/rules/ban-operators.ts
+var defaultOptions2 = [];
+var banOperatorsRule = ruleCreator({
+  defaultOptions: defaultOptions2,
+  meta: {
+    docs: {
+      description: "Disallow banned operators.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "RxJS operator is banned: {{name}}{{explanation}}."
+    },
+    schema: [
+      {
+        type: "object",
+        description: _commontags.stripIndent`
+          An object containing keys that are names of operators
+          and values that are either booleans or strings containing the explanation for the ban.`
+      }
+    ],
+    type: "problem"
+  },
+  name: "ban-operators",
+  create: (context) => {
+    const { couldBeType: couldBeType2 } = getTypeServices(context);
+    const bans = [];
+    const [config] = context.options;
+    if (!config) {
+      return {};
+    }
+    Object.entries(config).forEach(([key, value]) => {
+      if (value !== false) {
+        bans.push({
+          name: key,
+          explanation: typeof value === "string" ? value : ""
+        });
+      }
+    });
+    function checkNode(node) {
+      for (const ban of bans) {
+        if (couldBeType2(node, ban.name, { name: /[/\\]rxjs[/\\]/ })) {
+          const explanation = ban.explanation ? `: ${ban.explanation}` : "";
+          context.report({
+            messageId: "forbidden",
+            data: { name: ban.name, explanation },
+            node
+          });
+          return;
+        }
+      }
+    }
+    return {
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name]": (node) => {
+        checkNode(node.callee);
+      },
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.type=\"MemberExpression\"]": (node) => {
+        const callee = node.callee;
+        checkNode(callee.property);
+      }
+    };
+  }
+});
+
 // src/rules/finnish.ts
+
 var defaultOptions3 = [];
 var finnishRule = ruleCreator({
   defaultOptions: defaultOptions3,
@@ -923,11 +910,12 @@ var noCreateRule = ruleCreator({
 
 
 
+
 // src/constants.ts
 var defaultObservable = String.raw`[Aa]ction(s|s\$|\$)$`;
 
 // src/rules/no-cyclic-action.ts
-function isTypeReference3(type) {
+function isTypeReference2(type) {
   return Boolean(type.target);
 }
 var defaultOptions4 = [];
@@ -959,7 +947,8 @@ var noCyclicActionRule = ruleCreator({
     const [config = {}] = context.options;
     const { observable = defaultObservable } = config;
     const observableRegExp = new RegExp(observable);
-    const { getType, typeChecker } = getTypeServices(context);
+    const { getTypeAtLocation, program } = _utils.ESLintUtils.getParserServices(context);
+    const typeChecker = program.getTypeChecker();
     function checkNode(pipeCallExpression) {
       const operatorCallExpression = pipeCallExpression.arguments.find(
         (arg) => isCallExpression(arg) && isIdentifier(arg.callee) && arg.callee.name === "ofType"
@@ -967,7 +956,7 @@ var noCyclicActionRule = ruleCreator({
       if (!operatorCallExpression) {
         return;
       }
-      const operatorType = getType(operatorCallExpression);
+      const operatorType = getTypeAtLocation(operatorCallExpression);
       const [signature] = typeChecker.getSignaturesOfType(
         operatorType,
         _typescript2.default.SignatureKind.Call
@@ -976,15 +965,15 @@ var noCyclicActionRule = ruleCreator({
         return;
       }
       const operatorReturnType = typeChecker.getReturnTypeOfSignature(signature);
-      if (!isTypeReference3(operatorReturnType)) {
+      if (!isTypeReference2(operatorReturnType)) {
         return;
       }
       const [operatorElementType] = typeChecker.getTypeArguments(operatorReturnType);
       if (!operatorElementType) {
         return;
       }
-      const pipeType = getType(pipeCallExpression);
-      if (!isTypeReference3(pipeType)) {
+      const pipeType = getTypeAtLocation(pipeCallExpression);
+      if (!isTypeReference2(pipeType)) {
         return;
       }
       const [pipeElementType] = typeChecker.getTypeArguments(pipeType);
@@ -1278,7 +1267,110 @@ var noFinnishRule = ruleCreator({
   }
 });
 
+// src/rules/no-ignored-default-value.ts
+
+var noIgnoredDefaultValueRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value.",
+      requiresTypeChecking: true
+    },
+    messages: {
+      forbidden: "Not specifying a default value is forbidden."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-ignored-default-value",
+  create: (context) => {
+    const { getTypeAtLocation } = _utils.ESLintUtils.getParserServices(context);
+    const { couldBeObservable, couldBeType: couldBeType2 } = getTypeServices(context);
+    function checkConfigObj(configArg) {
+      if (!configArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "defaultValue")) {
+        context.report({
+          messageId: "forbidden",
+          node: configArg
+        });
+      }
+    }
+    function checkConfigType(configArg) {
+      const configArgType = getTypeAtLocation(configArg);
+      if (!(configArgType == null ? void 0 : configArgType.getProperties().some((p) => p.name === "defaultValue"))) {
+        context.report({
+          messageId: "forbidden",
+          node: configArg
+        });
+      }
+    }
+    function checkArg(arg) {
+      if (isIdentifier(arg)) {
+        checkConfigType(arg);
+        return;
+      } else if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        checkConfigType(arg.property);
+        return;
+      }
+      if (!isObjectExpression(arg)) {
+        return;
+      }
+      checkConfigObj(arg);
+    }
+    function checkFunctionArgs(node, args) {
+      if (!couldBeType2(node, "firstValueFrom", { name: /[/\\]rxjs[/\\]/ }) && !couldBeType2(node, "lastValueFrom", { name: /[/\\]rxjs[/\\]/ })) {
+        return;
+      }
+      if (!args || args.length <= 0) {
+        return;
+      }
+      const [observableArg, configArg] = args;
+      if (!couldBeObservable(observableArg)) {
+        return;
+      }
+      if (!configArg) {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+        return;
+      }
+      checkArg(configArg);
+    }
+    function checkOperatorArgs(node, args) {
+      if (!couldBeType2(node, "first", { name: /[/\\]rxjs[/\\]/ }) && !couldBeType2(node, "last", { name: /[/\\]rxjs[/\\]/ })) {
+        return;
+      }
+      if (!args || args.length <= 0) {
+        context.report({
+          messageId: "forbidden",
+          node
+        });
+        return;
+      }
+      const [arg] = args;
+      checkArg(arg);
+    }
+    return {
+      "CallExpression[callee.name=/^(firstValueFrom|lastValueFrom)$/]": (node) => {
+        checkFunctionArgs(node.callee, node.arguments);
+      },
+      "CallExpression[callee.property.name=/^(firstValueFrom|lastValueFrom)$/]": (node) => {
+        const memberExpression = node.callee;
+        checkFunctionArgs(memberExpression.property, node.arguments);
+      },
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.name=/^(first|last)$/]": (node) => {
+        checkOperatorArgs(node.callee, node.arguments);
+      },
+      "CallExpression[callee.property.name='pipe'] > CallExpression[callee.property.name=/^(first|last)$/]": (node) => {
+        const memberExpression = node.callee;
+        checkOperatorArgs(memberExpression.property, node.arguments);
+      }
+    };
+  }
+});
+
 // src/rules/no-ignored-error.ts
+
 var noIgnoredErrorRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1294,12 +1386,44 @@ var noIgnoredErrorRule = ruleCreator({
   },
   name: "no-ignored-error",
   create: (context) => {
+    const { getTypeAtLocation } = _utils.ESLintUtils.getParserServices(context);
     const { couldBeObservable, couldBeFunction: couldBeFunction2 } = getTypeServices(context);
+    function isMissingErrorCallback(callExpression) {
+      if (callExpression.arguments.length >= 2) {
+        return false;
+      }
+      return couldBeFunction2(callExpression.arguments[0]);
+    }
+    function isObjMissingError(arg) {
+      return !arg.properties.some(
+        (property) => isProperty(property) && isIdentifier(property.key) && property.key.name === "error"
+      );
+    }
+    function isTypeMissingError(arg) {
+      const argType = getTypeAtLocation(arg);
+      return !(argType == null ? void 0 : argType.getProperties().some((p) => p.name === "error"));
+    }
+    function isMissingErrorProperty(callExpression) {
+      if (callExpression.arguments.length !== 1) {
+        return false;
+      }
+      const [arg] = callExpression.arguments;
+      if (isObjectExpression(arg)) {
+        return isObjMissingError(arg);
+      }
+      if (isIdentifier(arg)) {
+        return isTypeMissingError(arg);
+      }
+      if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        return isTypeMissingError(arg.property);
+      }
+      return false;
+    }
     return {
       "CallExpression[arguments.length > 0] > MemberExpression > Identifier[name='subscribe']": (node) => {
         const memberExpression = node.parent;
         const callExpression = memberExpression.parent;
-        if (callExpression.arguments.length < 2 && couldBeObservable(memberExpression.object) && couldBeFunction2(callExpression.arguments[0])) {
+        if ((isMissingErrorCallback(callExpression) || isMissingErrorProperty(callExpression)) && couldBeObservable(memberExpression.object)) {
           context.report({
             messageId: "forbidden",
             node
@@ -1413,7 +1537,6 @@ var noIgnoredObservableRule = ruleCreator({
 });
 
 // src/rules/no-ignored-replay-buffer.ts
-
 var noIgnoredReplayBufferRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -1430,7 +1553,7 @@ var noIgnoredReplayBufferRule = ruleCreator({
   name: "no-ignored-replay-buffer",
   create: (context) => {
     function checkShareReplayConfig(node, shareReplayConfigArg) {
-      if (!shareReplayConfigArg.properties.some((p) => p.type === _utils.AST_NODE_TYPES.Property && p.key.type === _utils.AST_NODE_TYPES.Identifier && p.key.name === "bufferSize")) {
+      if (!shareReplayConfigArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "bufferSize")) {
         context.report({
           messageId: "forbidden",
           node
@@ -1445,8 +1568,8 @@ var noIgnoredReplayBufferRule = ruleCreator({
         });
       }
       if (node.name === "shareReplay" && (args == null ? void 0 : args.length) === 1) {
-        const arg = args[0];
-        if (arg.type === _utils.AST_NODE_TYPES.ObjectExpression) {
+        const [arg] = args;
+        if (isObjectExpression(arg)) {
           checkShareReplayConfig(node, arg);
         }
       }
@@ -2227,6 +2350,7 @@ var noTopromiseRule = ruleCreator({
 });
 
 // src/rules/no-unbound-methods.ts
+
 var noUnboundMethodsRule = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -2243,11 +2367,12 @@ var noUnboundMethodsRule = ruleCreator({
   },
   name: "no-unbound-methods",
   create: (context) => {
-    const { couldBeObservable, couldBeSubscription, getType } = getTypeServices(context);
+    const { getTypeAtLocation } = _utils.ESLintUtils.getParserServices(context);
+    const { couldBeObservable, couldBeSubscription } = getTypeServices(context);
     const nodeMap = /* @__PURE__ */ new WeakMap();
     function mapArguments(node) {
       node.arguments.filter(isMemberExpression).forEach((arg) => {
-        const argType = getType(arg);
+        const argType = getTypeAtLocation(arg);
         if (argType.getCallSignatures().length > 0) {
           nodeMap.set(arg);
         }
@@ -2422,6 +2547,7 @@ var noUnsafeFirstRule = ruleCreator({
 // src/rules/no-unsafe-subject-next.ts
 
 
+
 var noUnsafeSubjectNext = ruleCreator({
   defaultOptions: [],
   meta: {
@@ -2438,24 +2564,25 @@ var noUnsafeSubjectNext = ruleCreator({
   },
   name: "no-unsafe-subject-next",
   create: (context) => {
-    const { getType, typeChecker } = getTypeServices(context);
+    const { getTypeAtLocation, program } = _utils.ESLintUtils.getParserServices(context);
+    const typeChecker = program.getTypeChecker();
     return {
       [`CallExpression[callee.property.name='next']`]: (node) => {
         if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
-          const type = getType(node.callee.object);
-          if (tsutils3.isTypeReference(type) && couldBeType(type, "Subject")) {
+          const type = getTypeAtLocation(node.callee.object);
+          if (tsutils2.isTypeReference(type) && couldBeType(type, "Subject")) {
             const [typeArg] = typeChecker.getTypeArguments(type);
-            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
+            if (tsutils2.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Any)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
+            if (tsutils2.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Unknown)) {
               return;
             }
-            if (tsutils3.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
+            if (tsutils2.isTypeFlagSet(typeArg, _typescript2.default.TypeFlags.Void)) {
               return;
             }
-            if (tsutils3.isUnionType(typeArg) && typeArg.types.some(
-              (t) => tsutils3.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
+            if (tsutils2.isUnionType(typeArg) && typeArg.types.some(
+              (t) => tsutils2.isTypeFlagSet(t, _typescript2.default.TypeFlags.Void)
             )) {
               return;
             }
@@ -3001,47 +3128,73 @@ var suffixSubjectsRule = ruleCreator({
 // src/rules/throw-error.ts
 
 
+var defaultOptions14 = [];
 var throwErrorRule = ruleCreator({
-  defaultOptions: [],
+  defaultOptions: defaultOptions14,
   meta: {
     docs: {
-      description: "Enforce passing only `Error` values to error notifications.",
+      description: "Enforce passing only `Error` values to `throwError`.",
       requiresTypeChecking: true
     },
     messages: {
-      forbidden: "Passing non-Error values are forbidden."
+      forbidden: "Passing non-Error values is forbidden."
     },
-    schema: [],
+    schema: [
+      {
+        properties: {
+          allowThrowingAny: { type: "boolean", default: true, description: "Whether to always allow throwing values typed as `any`." },
+          allowThrowingUnknown: { type: "boolean", default: true, description: "Whether to always allow throwing values typed as `unknown`." }
+        },
+        type: "object"
+      }
+    ],
     type: "problem"
   },
   name: "throw-error",
   create: (context) => {
-    const { esTreeNodeToTSNodeMap, program } = _utils.ESLintUtils.getParserServices(context);
-    const { couldBeObservable, getType } = getTypeServices(context);
-    function checkNode(node) {
-      let type = getType(node);
+    const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = _utils.ESLintUtils.getParserServices(context);
+    const { couldBeObservable } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { allowThrowingAny = true, allowThrowingUnknown = true } = config;
+    function checkThrowArgument(node) {
+      var _a;
+      let type = getTypeAtLocation(node);
+      let reportNode = node;
       if (couldBeFunction(type)) {
+        reportNode = (_a = node.body) != null ? _a : node;
         const tsNode = esTreeNodeToTSNodeMap.get(node);
         const annotation = tsNode.type;
         const body = tsNode.body;
         type = program.getTypeChecker().getTypeAtLocation(annotation != null ? annotation : body);
       }
-      if (!tsutils4.isIntrinsicAnyType(type) && !tsutils4.isIntrinsicUnknownType(type) && !couldBeType(type, /^(Error|DOMException)$/)) {
-        context.report({
-          messageId: "forbidden",
-          node
-        });
+      if (allowThrowingAny && tsutils3.isIntrinsicAnyType(type)) {
+        return;
+      }
+      if (allowThrowingUnknown && tsutils3.isIntrinsicUnknownType(type)) {
+        return;
+      }
+      if (couldBeType(type, /^Error$/)) {
+        return;
+      }
+      context.report({
+        messageId: "forbidden",
+        node: reportNode
+      });
+    }
+    function checkNode(node) {
+      if (couldBeObservable(node)) {
+        const [arg] = node.arguments;
+        if (arg) {
+          checkThrowArgument(arg);
+        }
       }
     }
     return {
-      "ThrowStatement > *": checkNode,
       "CallExpression[callee.name='throwError']": (node) => {
-        if (couldBeObservable(node)) {
-          const [arg] = node.arguments;
-          if (arg) {
-            checkNode(arg);
-          }
-        }
+        checkNode(node);
+      },
+      "CallExpression[callee.property.name='throwError']": (node) => {
+        checkNode(node);
       }
     };
   }
@@ -3064,6 +3217,7 @@ var plugin = {
     "no-explicit-generics": noExplicitGenericsRule,
     "no-exposed-subjects": noExposedSubjectsRule,
     "no-finnish": noFinnishRule,
+    "no-ignored-default-value": noIgnoredDefaultValueRule,
     "no-ignored-error": noIgnoredErrorRule,
     "no-ignored-notifier": noIgnoredNotifierRule,
     "no-ignored-observable": noIgnoredObservableRule,