@depup/eslint-plugin-jsdoc 62.8.0-depup.0

package/dist/rules/requirePropertyType.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirePropertyType.cjs","names":["_iterateJsdoc","_interopRequireDefault","require","e","__esModule","default","_default","exports","iterateJsdoc","report","utils","forEachPreferredTag","jsdoc","targetTagName","type","name","iterateAllJsdocs","meta","docs","description","url","module"],"sources":["../../src/rules/requirePropertyType.js"],"sourcesContent":["import iterateJsdoc from '../iterateJsdoc.js';\n\nexport default iterateJsdoc(({\n  report,\n  utils,\n}) => {\n  utils.forEachPreferredTag('property', (jsdoc, targetTagName) => {\n    if (!jsdoc.type) {\n      report(\n        `Missing JSDoc @${targetTagName} \"${jsdoc.name}\" type.`,\n        null,\n        jsdoc,\n      );\n    }\n  });\n}, {\n  iterateAllJsdocs: true,\n  meta: {\n    docs: {\n      description: 'Requires that each `@property` tag has a type value (in curly brackets).',\n      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-property-type.md#repos-sticky-header',\n    },\n    type: 'suggestion',\n  },\n});\n"],"mappings":";;;;;;AAAA,IAAAA,aAAA,GAAAC,sBAAA,CAAAC,OAAA;AAA8C,SAAAD,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,IAAAG,QAAA,GAAAC,OAAA,CAAAF,OAAA,GAE/B,IAAAG,qBAAY,EAAC,CAAC;EAC3BC,MAAM;EACNC;AACF,CAAC,KAAK;EACJA,KAAK,CAACC,mBAAmB,CAAC,UAAU,EAAE,CAACC,KAAK,EAAEC,aAAa,KAAK;IAC9D,IAAI,CAACD,KAAK,CAACE,IAAI,EAAE;MACfL,MAAM,CACJ,kBAAkBI,aAAa,KAAKD,KAAK,CAACG,IAAI,SAAS,EACvD,IAAI,EACJH,KACF,CAAC;IACH;EACF,CAAC,CAAC;AACJ,CAAC,EAAE;EACDI,gBAAgB,EAAE,IAAI;EACtBC,IAAI,EAAE;IACJC,IAAI,EAAE;MACJC,WAAW,EAAE,0EAA0E;MACvFC,GAAG,EAAE;IACP,CAAC;IACDN,IAAI,EAAE;EACR;AACF,CAAC,CAAC;AAAAO,MAAA,CAAAd,OAAA,GAAAA,OAAA,CAAAF,OAAA","ignoreList":[]}

package/dist/rules/requirePropertyType.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;
+//# sourceMappingURL=requirePropertyType.d.ts.map

package/dist/rules/requireRejects.cjs

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Checks if a node or its children contain Promise rejection patterns
+ * @param {import('eslint').Rule.Node} node
+ * @param {boolean} [innerFunction]
+ * @param {boolean} [isAsync]
+ * @returns {boolean}
+ */
+// eslint-disable-next-line complexity -- Temporary
+const hasRejectValue = (node, innerFunction, isAsync) => {
+  if (!node) {
+    return false;
+  }
+  switch (node.type) {
+    case 'ArrowFunctionExpression':
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+      {
+        // For inner functions in async contexts, check if they throw
+        // (they could be called and cause rejection)
+        if (innerFunction) {
+          // Check inner functions for throws - if called from async context, throws become rejections
+          const innerIsAsync = node.async;
+          // Pass isAsync=true if the inner function is async OR if we're already in an async context
+          return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.body, false, innerIsAsync || isAsync);
+        }
+
+        // This is the top-level function we're checking
+        return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.body, true, node.async);
+      }
+    case 'BlockStatement':
+      {
+        return node.body.some(bodyNode => {
+          return hasRejectValue(/** @type {import('eslint').Rule.Node} */bodyNode, innerFunction, isAsync);
+        });
+      }
+    case 'CallExpression':
+      {
+        // Check for Promise.reject()
+        if (node.callee.type === 'MemberExpression' && node.callee.object.type === 'Identifier' && node.callee.object.name === 'Promise' && node.callee.property.type === 'Identifier' && node.callee.property.name === 'reject') {
+          return true;
+        }
+
+        // Check for reject() call (in Promise executor context)
+        if (node.callee.type === 'Identifier' && node.callee.name === 'reject') {
+          return true;
+        }
+
+        // Check if this is calling an inner function that might reject
+        if (innerFunction && node.callee.type === 'Identifier') {
+          // We found a function call inside - check if it could be calling a function that rejects
+          // We'll handle this in function body traversal
+          return false;
+        }
+        return false;
+      }
+    case 'DoWhileStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'ForStatement':
+    case 'LabeledStatement':
+    case 'WhileStatement':
+    case 'WithStatement':
+      {
+        return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.body, innerFunction, isAsync);
+      }
+    case 'ExpressionStatement':
+      {
+        return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.expression, innerFunction, isAsync);
+      }
+    case 'IfStatement':
+      {
+        return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.consequent, innerFunction, isAsync) || hasRejectValue(/** @type {import('eslint').Rule.Node} */node.alternate, innerFunction, isAsync);
+      }
+    case 'NewExpression':
+      {
+        // Check for new Promise((resolve, reject) => { reject(...) })
+        if (node.callee.type === 'Identifier' && node.callee.name === 'Promise' && node.arguments.length > 0) {
+          const executor = node.arguments[0];
+          if (executor.type === 'ArrowFunctionExpression' || executor.type === 'FunctionExpression') {
+            // Check if the executor has reject() calls
+            return hasRejectValue(/** @type {import('eslint').Rule.Node} */executor.body, false, false);
+          }
+        }
+        return false;
+      }
+    case 'ReturnStatement':
+      {
+        if (node.argument) {
+          return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.argument, innerFunction, isAsync);
+        }
+        return false;
+      }
+    case 'SwitchStatement':
+      {
+        return node.cases.some(someCase => {
+          return someCase.consequent.some(nde => {
+            return hasRejectValue(/** @type {import('eslint').Rule.Node} */nde, innerFunction, isAsync);
+          });
+        });
+      }
+
+    // Throw statements in async functions become rejections
+    case 'ThrowStatement':
+      {
+        return isAsync === true;
+      }
+    case 'TryStatement':
+      {
+        return hasRejectValue(/** @type {import('eslint').Rule.Node} */node.handler && node.handler.body, innerFunction, isAsync) || hasRejectValue(/** @type {import('eslint').Rule.Node} */node.finalizer, innerFunction, isAsync);
+      }
+    default:
+      {
+        return false;
+      }
+  }
+};
+
+/**
+ * We can skip checking for a rejects value, in case the documentation is inherited
+ * or the method is abstract.
+ * @param {import('../iterateJsdoc.js').Utils} utils
+ * @returns {boolean}
+ */
+const canSkip = utils => {
+  return utils.hasATag(['abstract', 'virtual', 'type']) || utils.avoidDocs();
+};
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  node,
+  report,
+  utils
+}) => {
+  if (canSkip(utils)) {
+    return;
+  }
+  const tagName = /** @type {string} */utils.getPreferredTagName({
+    tagName: 'rejects'
+  });
+  if (!tagName) {
+    return;
+  }
+  const tags = utils.getTags(tagName);
+  const iteratingFunction = utils.isIteratingFunction();
+  const [tag] = tags;
+  const missingRejectsTag = typeof tag === 'undefined' || tag === null;
+  const shouldReport = () => {
+    if (!missingRejectsTag) {
+      return false;
+    }
+
+    // Check if this is an async function or returns a Promise
+    const isAsync = utils.isAsync();
+    if (!isAsync && !iteratingFunction) {
+      return false;
+    }
+
+    // For async functions, check for throw statements
+    // For regular functions, check for Promise.reject or reject calls
+    return hasRejectValue(/** @type {import('eslint').Rule.Node} */node);
+  };
+  if (shouldReport()) {
+    report('Promise-rejecting function requires `@rejects` tag');
+  }
+}, {
+  contextDefaults: true,
+  meta: {
+    docs: {
+      description: 'Requires that Promise rejections are documented with `@rejects` tags.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-rejects.md#repos-sticky-header'
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        contexts: {
+          description: `Set this to an array of strings representing the AST context
+(or objects with optional \`context\` and \`comment\` properties) where you wish
+the rule to be applied.
+
+\`context\` defaults to \`any\` and \`comment\` defaults to no specific comment context.
+
+Overrides the default contexts (\`ArrowFunctionExpression\`, \`FunctionDeclaration\`,
+\`FunctionExpression\`).`,
+          items: {
+            anyOf: [{
+              type: 'string'
+            }, {
+              additionalProperties: false,
+              properties: {
+                comment: {
+                  type: 'string'
+                },
+                context: {
+                  type: 'string'
+                }
+              },
+              type: 'object'
+            }]
+          },
+          type: 'array'
+        },
+        exemptedBy: {
+          description: `Array of tags (e.g., \`['type']\`) whose presence on the
+document block avoids the need for a \`@rejects\`. Defaults to an array
+with \`abstract\`, \`virtual\`, and \`type\`. If you set this array, it will overwrite the default,
+so be sure to add back those tags if you wish their presence to cause
+exemption of the rule.`,
+          items: {
+            type: 'string'
+          },
+          type: 'array'
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireRejects.cjs.map

package/dist/rules/requireRejects.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireRejects.cjs","names":["_iterateJsdoc","_interopRequireDefault","require","e","__esModule","default","hasRejectValue","node","innerFunction","isAsync","type","innerIsAsync","async","body","some","bodyNode","callee","object","name","property","expression","consequent","alternate","arguments","length","executor","argument","cases","someCase","nde","handler","finalizer","canSkip","utils","hasATag","avoidDocs","_default","exports","iterateJsdoc","report","tagName","getPreferredTagName","tags","getTags","iteratingFunction","isIteratingFunction","tag","missingRejectsTag","shouldReport","contextDefaults","meta","docs","description","url","schema","additionalProperties","properties","contexts","items","anyOf","comment","context","exemptedBy","module"],"sources":["../../src/rules/requireRejects.js"],"sourcesContent":["import iterateJsdoc from '../iterateJsdoc.js';\n\n/**\n * Checks if a node or its children contain Promise rejection patterns\n * @param {import('eslint').Rule.Node} node\n * @param {boolean} [innerFunction]\n * @param {boolean} [isAsync]\n * @returns {boolean}\n */\n// eslint-disable-next-line complexity -- Temporary\nconst hasRejectValue = (node, innerFunction, isAsync) => {\n  if (!node) {\n    return false;\n  }\n\n  switch (node.type) {\n    case 'ArrowFunctionExpression':\n    case 'FunctionDeclaration':\n    case 'FunctionExpression': {\n      // For inner functions in async contexts, check if they throw\n      // (they could be called and cause rejection)\n      if (innerFunction) {\n        // Check inner functions for throws - if called from async context, throws become rejections\n        const innerIsAsync = node.async;\n        // Pass isAsync=true if the inner function is async OR if we're already in an async context\n        return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.body), false, innerIsAsync || isAsync);\n      }\n\n      // This is the top-level function we're checking\n      return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.body), true, node.async);\n    }\n\n    case 'BlockStatement': {\n      return node.body.some((bodyNode) => {\n        return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (bodyNode), innerFunction, isAsync);\n      });\n    }\n\n    case 'CallExpression': {\n      // Check for Promise.reject()\n      if (node.callee.type === 'MemberExpression' &&\n          node.callee.object.type === 'Identifier' &&\n          node.callee.object.name === 'Promise' &&\n          node.callee.property.type === 'Identifier' &&\n          node.callee.property.name === 'reject') {\n        return true;\n      }\n\n      // Check for reject() call (in Promise executor context)\n      if (node.callee.type === 'Identifier' && node.callee.name === 'reject') {\n        return true;\n      }\n\n      // Check if this is calling an inner function that might reject\n      if (innerFunction && node.callee.type === 'Identifier') {\n        // We found a function call inside - check if it could be calling a function that rejects\n        // We'll handle this in function body traversal\n        return false;\n      }\n\n      return false;\n    }\n\n    case 'DoWhileStatement':\n    case 'ForInStatement':\n    case 'ForOfStatement':\n    case 'ForStatement':\n    case 'LabeledStatement':\n    case 'WhileStatement':\n\n    case 'WithStatement': {\n      return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.body), innerFunction, isAsync);\n    }\n\n    case 'ExpressionStatement': {\n      return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.expression), innerFunction, isAsync);\n    }\n\n    case 'IfStatement': {\n      return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.consequent), innerFunction, isAsync) || hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.alternate), innerFunction, isAsync);\n    }\n\n    case 'NewExpression': {\n      // Check for new Promise((resolve, reject) => { reject(...) })\n      if (node.callee.type === 'Identifier' && node.callee.name === 'Promise' && node.arguments.length > 0) {\n        const executor = node.arguments[0];\n        if (executor.type === 'ArrowFunctionExpression' || executor.type === 'FunctionExpression') {\n          // Check if the executor has reject() calls\n          return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (executor.body), false, false);\n        }\n      }\n\n      return false;\n    }\n\n    case 'ReturnStatement': {\n      if (node.argument) {\n        return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.argument), innerFunction, isAsync);\n      }\n\n      return false;\n    }\n\n    case 'SwitchStatement': {\n      return node.cases.some(\n        (someCase) => {\n          return someCase.consequent.some((nde) => {\n            return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (nde), innerFunction, isAsync);\n          });\n        },\n      );\n    }\n\n    // Throw statements in async functions become rejections\n    case 'ThrowStatement': {\n      return isAsync === true;\n    }\n\n    case 'TryStatement': {\n      return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.handler && node.handler.body), innerFunction, isAsync) ||\n        hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node.finalizer), innerFunction, isAsync);\n    }\n\n    default: {\n      return false;\n    }\n  }\n};\n\n/**\n * We can skip checking for a rejects value, in case the documentation is inherited\n * or the method is abstract.\n * @param {import('../iterateJsdoc.js').Utils} utils\n * @returns {boolean}\n */\nconst canSkip = (utils) => {\n  return utils.hasATag([\n    'abstract',\n    'virtual',\n    'type',\n  ]) ||\n    utils.avoidDocs();\n};\n\nexport default iterateJsdoc(({\n  node,\n  report,\n  utils,\n}) => {\n  if (canSkip(utils)) {\n    return;\n  }\n\n  const tagName = /** @type {string} */ (utils.getPreferredTagName({\n    tagName: 'rejects',\n  }));\n  if (!tagName) {\n    return;\n  }\n\n  const tags = utils.getTags(tagName);\n  const iteratingFunction = utils.isIteratingFunction();\n\n  const [\n    tag,\n  ] = tags;\n  const missingRejectsTag = typeof tag === 'undefined' || tag === null;\n\n  const shouldReport = () => {\n    if (!missingRejectsTag) {\n      return false;\n    }\n\n    // Check if this is an async function or returns a Promise\n    const isAsync = utils.isAsync();\n    if (!isAsync && !iteratingFunction) {\n      return false;\n    }\n\n    // For async functions, check for throw statements\n    // For regular functions, check for Promise.reject or reject calls\n    return hasRejectValue(/** @type {import('eslint').Rule.Node} */ (node));\n  };\n\n  if (shouldReport()) {\n    report('Promise-rejecting function requires `@rejects` tag');\n  }\n}, {\n  contextDefaults: true,\n  meta: {\n    docs: {\n      description: 'Requires that Promise rejections are documented with `@rejects` tags.',\n      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-rejects.md#repos-sticky-header',\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          contexts: {\n            description: `Set this to an array of strings representing the AST context\n(or objects with optional \\`context\\` and \\`comment\\` properties) where you wish\nthe rule to be applied.\n\n\\`context\\` defaults to \\`any\\` and \\`comment\\` defaults to no specific comment context.\n\nOverrides the default contexts (\\`ArrowFunctionExpression\\`, \\`FunctionDeclaration\\`,\n\\`FunctionExpression\\`).`,\n            items: {\n              anyOf: [\n                {\n                  type: 'string',\n                },\n                {\n                  additionalProperties: false,\n                  properties: {\n                    comment: {\n                      type: 'string',\n                    },\n                    context: {\n                      type: 'string',\n                    },\n                  },\n                  type: 'object',\n                },\n              ],\n            },\n            type: 'array',\n          },\n          exemptedBy: {\n            description: `Array of tags (e.g., \\`['type']\\`) whose presence on the\ndocument block avoids the need for a \\`@rejects\\`. Defaults to an array\nwith \\`abstract\\`, \\`virtual\\`, and \\`type\\`. If you set this array, it will overwrite the default,\nso be sure to add back those tags if you wish their presence to cause\nexemption of the rule.`,\n            items: {\n              type: 'string',\n            },\n            type: 'array',\n          },\n        },\n        type: 'object',\n      },\n    ],\n    type: 'suggestion',\n  },\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/rules/requireRejects.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;
+//# sourceMappingURL=requireRejects.d.ts.map

package/dist/rules/requireReturns.cjs

@@ -0,0 +1,262 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _exportParser = _interopRequireDefault(require("../exportParser.cjs"));
+var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * We can skip checking for a return value, in case the documentation is inherited
+ * or the method is either a constructor or an abstract method.
+ *
+ * In either of these cases the return value is optional or not defined.
+ * @param {import('../iterateJsdoc.js').Utils} utils
+ *   a reference to the utils which are used to probe if a tag is present or not.
+ * @returns {boolean}
+ *   true in case deep checking can be skipped; otherwise false.
+ */
+const canSkip = utils => {
+  return utils.hasATag([
+  // inheritdoc implies that all documentation is inherited
+  // see https://jsdoc.app/tags-inheritdoc.html
+  //
+  // Abstract methods are by definition incomplete,
+  // so it is not an error if it declares a return value but does not implement it.
+  'abstract', 'virtual',
+  // Constructors do not have a return value by definition (https://jsdoc.app/tags-class.html)
+  // So we can bail out here, too.
+  'class', 'constructor',
+  // Return type is specified by type in @type
+  'type',
+  // This seems to imply a class as well
+  'interface']) || utils.avoidDocs();
+};
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  context,
+  info: {
+    comment
+  },
+  node,
+  report,
+  settings,
+  utils
+}) => {
+  const {
+    contexts,
+    enableFixer = false,
+    forceRequireReturn = false,
+    forceReturnsWithAsync = false,
+    publicOnly = false
+  } = context.options[0] || {};
+
+  // A preflight check. We do not need to run a deep check
+  // in case the @returns comment is optional or undefined.
+  if (canSkip(utils)) {
+    return;
+  }
+
+  /** @type {boolean|undefined} */
+  let forceRequireReturnContext;
+  if (contexts) {
+    const {
+      foundContext
+    } = utils.findContext(contexts, comment);
+    if (typeof foundContext === 'object') {
+      forceRequireReturnContext = foundContext.forceRequireReturn;
+    }
+  }
+  const tagName = /** @type {string} */utils.getPreferredTagName({
+    tagName: 'returns'
+  });
+  if (!tagName) {
+    return;
+  }
+  const tags = utils.getTags(tagName);
+  if (tags.length > 1) {
+    report(`Found more than one @${tagName} declaration.`);
+  }
+  const iteratingFunction = utils.isIteratingFunction();
+
+  // In case the code returns something, we expect a return value in JSDoc.
+  const [tag] = tags;
+  const missingReturnTag = typeof tag === 'undefined' || tag === null;
+  const shouldReport = () => {
+    if (!missingReturnTag) {
+      return false;
+    }
+    if (publicOnly) {
+      /** @type {import('./requireJsdoc.js').RequireJsdocOpts} */
+      const opt = {
+        ancestorsOnly: Boolean(publicOnly?.ancestorsOnly ?? false),
+        esm: Boolean(publicOnly?.esm ?? true),
+        initModuleExports: Boolean(publicOnly?.cjs ?? true),
+        initWindow: Boolean(publicOnly?.window ?? false)
+      };
+      /* c8 ignore next -- Fallback to deprecated method */
+      const {
+        // @ts-expect-error ESLint < 10
+        sourceCode = context.getSourceCode()
+      } = context;
+      const exported = _exportParser.default.isUncommentedExport(/** @type {import('eslint').Rule.Node} */node, sourceCode, opt, settings);
+      if (!exported) {
+        return false;
+      }
+    }
+    if ((forceRequireReturn || forceRequireReturnContext) && (iteratingFunction || utils.isVirtualFunction())) {
+      return true;
+    }
+    const isAsync = !iteratingFunction && utils.hasTag('async') || iteratingFunction && utils.isAsync();
+    if (forceReturnsWithAsync && isAsync) {
+      return true;
+    }
+    return iteratingFunction && utils.hasValueOrExecutorHasNonEmptyResolveValue(forceReturnsWithAsync);
+  };
+  if (shouldReport()) {
+    utils.reportJSDoc(`Missing JSDoc @${tagName} declaration.`, null, enableFixer ? () => {
+      utils.addTag(tagName);
+    } : null);
+  }
+}, {
+  contextDefaults: true,
+  meta: {
+    docs: {
+      description: 'Requires that returns are documented with `@returns`.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns.md#repos-sticky-header'
+    },
+    fixable: 'code',
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        checkConstructors: {
+          default: false,
+          description: `A value indicating whether \`constructor\`s should
+be checked for \`@returns\` tags. Defaults to \`false\`.`,
+          type: 'boolean'
+        },
+        checkGetters: {
+          default: true,
+          description: `Boolean to determine whether getter methods should
+be checked for \`@returns\` tags. Defaults to \`true\`.`,
+          type: 'boolean'
+        },
+        contexts: {
+          description: `Set this to an array of strings representing the AST context
+(or objects with optional \`context\` and \`comment\` properties) where you wish
+the rule to be applied.
+
+\`context\` defaults to \`any\` and \`comment\` defaults to no specific comment context.
+
+Overrides the default contexts (\`ArrowFunctionExpression\`, \`FunctionDeclaration\`,
+\`FunctionExpression\`). Set to \`"any"\` if you want
+the rule to apply to any JSDoc block throughout your files (as is necessary
+for finding function blocks not attached to a function declaration or
+expression, i.e., \`@callback\` or \`@function\` (or its aliases \`@func\` or
+\`@method\`) (including those associated with an \`@interface\`). This
+rule will only apply on non-default contexts when there is such a tag
+present and the \`forceRequireReturn\` option is set or if the
+\`forceReturnsWithAsync\` option is set with a present \`@async\` tag
+(since we are not checking against the actual \`return\` values in these
+cases).`,
+          items: {
+            anyOf: [{
+              type: 'string'
+            }, {
+              additionalProperties: false,
+              properties: {
+                comment: {
+                  type: 'string'
+                },
+                context: {
+                  type: 'string'
+                },
+                forceRequireReturn: {
+                  type: 'boolean'
+                }
+              },
+              type: 'object'
+            }]
+          },
+          type: 'array'
+        },
+        enableFixer: {
+          description: `Whether to enable the fixer to add a blank \`@returns\`.
+Defaults to \`false\`.`,
+          type: 'boolean'
+        },
+        exemptedBy: {
+          description: `Array of tags (e.g., \`['type']\`) whose presence on the
+document block avoids the need for a \`@returns\`. Defaults to an array
+with \`inheritdoc\`. If you set this array, it will overwrite the default,
+so be sure to add back \`inheritdoc\` if you wish its presence to cause
+exemption of the rule.`,
+          items: {
+            type: 'string'
+          },
+          type: 'array'
+        },
+        forceRequireReturn: {
+          default: false,
+          description: `Set to \`true\` to always insist on
+\`@returns\` documentation regardless of implicit or explicit \`return\`'s
+in the function. May be desired to flag that a project is aware of an
+\`undefined\`/\`void\` return. Defaults to \`false\`.`,
+          type: 'boolean'
+        },
+        forceReturnsWithAsync: {
+          default: false,
+          description: `By default \`async\` functions that do not explicitly
+return a value pass this rule as an \`async\` function will always return a
+\`Promise\`, even if the \`Promise\` resolves to void. You can force all
+\`async\` functions (including ones with an explicit \`Promise\` but no
+detected non-\`undefined\` \`resolve\` value) to require \`@return\`
+documentation by setting \`forceReturnsWithAsync\` to \`true\` on the options
+object. This may be useful for flagging that there has been consideration
+of return type. Defaults to \`false\`.`,
+          type: 'boolean'
+        },
+        publicOnly: {
+          description: `This option will insist that missing \`@returns\` are only reported for
+function bodies / class declarations that are exported from the module.
+May be a boolean or object. If set to \`true\`, the defaults below will be
+used. If unset, \`@returns\` reporting will not be limited to exports.
+
+This object supports the following optional boolean keys (\`false\` unless
+otherwise noted):
+
+- \`ancestorsOnly\` - Optimization to only check node ancestors to check if node is exported
+- \`esm\` - ESM exports are checked for \`@returns\` JSDoc comments (Defaults to \`true\`)
+- \`cjs\` - CommonJS exports are checked for \`@returns\` JSDoc comments  (Defaults to \`true\`)
+- \`window\` - Window global exports are checked for \`@returns\` JSDoc comments`,
+          oneOf: [{
+            default: false,
+            type: 'boolean'
+          }, {
+            additionalProperties: false,
+            default: {},
+            properties: {
+              ancestorsOnly: {
+                type: 'boolean'
+              },
+              cjs: {
+                type: 'boolean'
+              },
+              esm: {
+                type: 'boolean'
+              },
+              window: {
+                type: 'boolean'
+              }
+            },
+            type: 'object'
+          }]
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireReturns.cjs.map

package/dist/rules/requireReturns.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireReturns.cjs","names":["_exportParser","_interopRequireDefault","require","_iterateJsdoc","e","__esModule","default","canSkip","utils","hasATag","avoidDocs","_default","exports","iterateJsdoc","context","info","comment","node","report","settings","contexts","enableFixer","forceRequireReturn","forceReturnsWithAsync","publicOnly","options","forceRequireReturnContext","foundContext","findContext","tagName","getPreferredTagName","tags","getTags","length","iteratingFunction","isIteratingFunction","tag","missingReturnTag","shouldReport","opt","ancestorsOnly","Boolean","esm","initModuleExports","cjs","initWindow","window","sourceCode","getSourceCode","exported","exportParser","isUncommentedExport","isVirtualFunction","isAsync","hasTag","hasValueOrExecutorHasNonEmptyResolveValue","reportJSDoc","addTag","contextDefaults","meta","docs","description","url","fixable","schema","additionalProperties","properties","checkConstructors","type","checkGetters","items","anyOf","exemptedBy","oneOf","module"],"sources":["../../src/rules/requireReturns.js"],"sourcesContent":["import exportParser from '../exportParser.js';\nimport iterateJsdoc from '../iterateJsdoc.js';\n\n/**\n * We can skip checking for a return value, in case the documentation is inherited\n * or the method is either a constructor or an abstract method.\n *\n * In either of these cases the return value is optional or not defined.\n * @param {import('../iterateJsdoc.js').Utils} utils\n *   a reference to the utils which are used to probe if a tag is present or not.\n * @returns {boolean}\n *   true in case deep checking can be skipped; otherwise false.\n */\nconst canSkip = (utils) => {\n  return utils.hasATag([\n    // inheritdoc implies that all documentation is inherited\n    // see https://jsdoc.app/tags-inheritdoc.html\n    //\n    // Abstract methods are by definition incomplete,\n    // so it is not an error if it declares a return value but does not implement it.\n    'abstract',\n    'virtual',\n\n    // Constructors do not have a return value by definition (https://jsdoc.app/tags-class.html)\n    // So we can bail out here, too.\n    'class',\n    'constructor',\n\n    // Return type is specified by type in @type\n    'type',\n\n    // This seems to imply a class as well\n    'interface',\n  ]) ||\n    utils.avoidDocs();\n};\n\nexport default iterateJsdoc(({\n  context,\n  info: {\n    comment,\n  },\n  node,\n  report,\n  settings,\n  utils,\n}) => {\n  const {\n    contexts,\n    enableFixer = false,\n    forceRequireReturn = false,\n    forceReturnsWithAsync = false,\n    publicOnly = false,\n  } = context.options[0] || {};\n\n  // A preflight check. We do not need to run a deep check\n  // in case the @returns comment is optional or undefined.\n  if (canSkip(utils)) {\n    return;\n  }\n\n  /** @type {boolean|undefined} */\n  let forceRequireReturnContext;\n  if (contexts) {\n    const {\n      foundContext,\n    } = utils.findContext(contexts, comment);\n    if (typeof foundContext === 'object') {\n      forceRequireReturnContext = foundContext.forceRequireReturn;\n    }\n  }\n\n  const tagName = /** @type {string} */ (utils.getPreferredTagName({\n    tagName: 'returns',\n  }));\n  if (!tagName) {\n    return;\n  }\n\n  const tags = utils.getTags(tagName);\n\n  if (tags.length > 1) {\n    report(`Found more than one @${tagName} declaration.`);\n  }\n\n  const iteratingFunction = utils.isIteratingFunction();\n\n  // In case the code returns something, we expect a return value in JSDoc.\n  const [\n    tag,\n  ] = tags;\n  const missingReturnTag = typeof tag === 'undefined' || tag === null;\n\n  const shouldReport = () => {\n    if (!missingReturnTag) {\n      return false;\n    }\n\n    if (publicOnly) {\n      /** @type {import('./requireJsdoc.js').RequireJsdocOpts} */\n      const opt = {\n        ancestorsOnly: Boolean(publicOnly?.ancestorsOnly ?? false),\n        esm: Boolean(publicOnly?.esm ?? true),\n        initModuleExports: Boolean(publicOnly?.cjs ?? true),\n        initWindow: Boolean(publicOnly?.window ?? false),\n      };\n      /* c8 ignore next -- Fallback to deprecated method */\n      const {\n        // @ts-expect-error ESLint < 10\n        sourceCode = context.getSourceCode(),\n      } = context;\n      const exported = exportParser.isUncommentedExport(\n        /** @type {import('eslint').Rule.Node} */ (node), sourceCode, opt, settings,\n      );\n\n      if (!exported) {\n        return false;\n      }\n    }\n\n    if ((forceRequireReturn || forceRequireReturnContext) && (\n      iteratingFunction || utils.isVirtualFunction()\n    )) {\n      return true;\n    }\n\n    const isAsync = !iteratingFunction && utils.hasTag('async') ||\n      iteratingFunction && utils.isAsync();\n\n    if (forceReturnsWithAsync && isAsync) {\n      return true;\n    }\n\n    return iteratingFunction && utils.hasValueOrExecutorHasNonEmptyResolveValue(\n      forceReturnsWithAsync,\n    );\n  };\n\n  if (shouldReport()) {\n    utils.reportJSDoc(`Missing JSDoc @${tagName} declaration.`, null, enableFixer ? () => {\n      utils.addTag(tagName);\n    } : null);\n  }\n}, {\n  contextDefaults: true,\n  meta: {\n    docs: {\n      description: 'Requires that returns are documented with `@returns`.',\n      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns.md#repos-sticky-header',\n    },\n    fixable: 'code',\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          checkConstructors: {\n            default: false,\n            description: `A value indicating whether \\`constructor\\`s should\nbe checked for \\`@returns\\` tags. Defaults to \\`false\\`.`,\n            type: 'boolean',\n          },\n          checkGetters: {\n            default: true,\n            description: `Boolean to determine whether getter methods should\nbe checked for \\`@returns\\` tags. Defaults to \\`true\\`.`,\n            type: 'boolean',\n          },\n          contexts: {\n            description: `Set this to an array of strings representing the AST context\n(or objects with optional \\`context\\` and \\`comment\\` properties) where you wish\nthe rule to be applied.\n\n\\`context\\` defaults to \\`any\\` and \\`comment\\` defaults to no specific comment context.\n\nOverrides the default contexts (\\`ArrowFunctionExpression\\`, \\`FunctionDeclaration\\`,\n\\`FunctionExpression\\`). Set to \\`\"any\"\\` if you want\nthe rule to apply to any JSDoc block throughout your files (as is necessary\nfor finding function blocks not attached to a function declaration or\nexpression, i.e., \\`@callback\\` or \\`@function\\` (or its aliases \\`@func\\` or\n\\`@method\\`) (including those associated with an \\`@interface\\`). This\nrule will only apply on non-default contexts when there is such a tag\npresent and the \\`forceRequireReturn\\` option is set or if the\n\\`forceReturnsWithAsync\\` option is set with a present \\`@async\\` tag\n(since we are not checking against the actual \\`return\\` values in these\ncases).`,\n            items: {\n              anyOf: [\n                {\n                  type: 'string',\n                },\n                {\n                  additionalProperties: false,\n                  properties: {\n                    comment: {\n                      type: 'string',\n                    },\n                    context: {\n                      type: 'string',\n                    },\n                    forceRequireReturn: {\n                      type: 'boolean',\n                    },\n                  },\n                  type: 'object',\n                },\n              ],\n            },\n            type: 'array',\n          },\n          enableFixer: {\n            description: `Whether to enable the fixer to add a blank \\`@returns\\`.\nDefaults to \\`false\\`.`,\n            type: 'boolean',\n          },\n          exemptedBy: {\n            description: `Array of tags (e.g., \\`['type']\\`) whose presence on the\ndocument block avoids the need for a \\`@returns\\`. Defaults to an array\nwith \\`inheritdoc\\`. If you set this array, it will overwrite the default,\nso be sure to add back \\`inheritdoc\\` if you wish its presence to cause\nexemption of the rule.`,\n            items: {\n              type: 'string',\n            },\n            type: 'array',\n          },\n          forceRequireReturn: {\n            default: false,\n            description: `Set to \\`true\\` to always insist on\n\\`@returns\\` documentation regardless of implicit or explicit \\`return\\`'s\nin the function. May be desired to flag that a project is aware of an\n\\`undefined\\`/\\`void\\` return. Defaults to \\`false\\`.`,\n            type: 'boolean',\n          },\n          forceReturnsWithAsync: {\n            default: false,\n            description: `By default \\`async\\` functions that do not explicitly\nreturn a value pass this rule as an \\`async\\` function will always return a\n\\`Promise\\`, even if the \\`Promise\\` resolves to void. You can force all\n\\`async\\` functions (including ones with an explicit \\`Promise\\` but no\ndetected non-\\`undefined\\` \\`resolve\\` value) to require \\`@return\\`\ndocumentation by setting \\`forceReturnsWithAsync\\` to \\`true\\` on the options\nobject. This may be useful for flagging that there has been consideration\nof return type. Defaults to \\`false\\`.`,\n            type: 'boolean',\n          },\n          publicOnly: {\n            description: `This option will insist that missing \\`@returns\\` are only reported for\nfunction bodies / class declarations that are exported from the module.\nMay be a boolean or object. If set to \\`true\\`, the defaults below will be\nused. If unset, \\`@returns\\` reporting will not be limited to exports.\n\nThis object supports the following optional boolean keys (\\`false\\` unless\notherwise noted):\n\n- \\`ancestorsOnly\\` - Optimization to only check node ancestors to check if node is exported\n- \\`esm\\` - ESM exports are checked for \\`@returns\\` JSDoc comments (Defaults to \\`true\\`)\n- \\`cjs\\` - CommonJS exports are checked for \\`@returns\\` JSDoc comments  (Defaults to \\`true\\`)\n- \\`window\\` - Window global exports are checked for \\`@returns\\` JSDoc comments`,\n            oneOf: [\n              {\n                default: false,\n                type: 'boolean',\n              },\n              {\n                additionalProperties: false,\n                default: {},\n                properties: {\n                  ancestorsOnly: {\n                    type: 'boolean',\n                  },\n                  cjs: {\n                    type: 'boolean',\n                  },\n                  esm: {\n                    type: 'boolean',\n                  },\n                  window: {\n                    type: 'boolean',\n                  },\n                },\n                type: 'object',\n              },\n            ],\n          },\n        },\n        type: 'object',\n      },\n    ],\n    type: 'suggestion',\n  },\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/rules/requireReturns.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;
+//# sourceMappingURL=requireReturns.d.ts.map