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

package/dist/rules/requireReturnsCheck.cjs

@@ -0,0 +1,140 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.cjs"));
+var _jsdocUtils = require("../jsdocUtils.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * @param {import('../iterateJsdoc.js').Utils} utils
+ * @param {import('../iterateJsdoc.js').Settings} settings
+ * @returns {boolean}
+ */
+const canSkip = (utils, settings) => {
+  const voidingTags = [
+  // An abstract function is by definition incomplete
+  // so it is perfectly fine if a return is documented but
+  // not present within the function.
+  // A subclass may inherit the doc and implement the
+  // missing return.
+  'abstract', 'virtual',
+  // A constructor function returns `this` by default, so may be `@returns`
+  //   tag indicating this but no explicit return
+  'class', 'constructor', 'interface'];
+  if (settings.mode === 'closure') {
+    // Structural Interface in GCC terms, equivalent to @interface tag as far as this rule is concerned
+    voidingTags.push('record');
+  }
+  return utils.hasATag(voidingTags) || utils.isConstructor() || utils.classHasTag('interface') || settings.mode === 'closure' && utils.classHasTag('record');
+};
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  context,
+  node,
+  report,
+  settings,
+  utils
+}) => {
+  const {
+    exemptAsync = true,
+    exemptGenerators = settings.mode === 'typescript',
+    noNativeTypes = true,
+    reportMissingReturnForUndefinedTypes = false
+  } = context.options[0] || {};
+  if (canSkip(utils, settings)) {
+    return;
+  }
+  const isAsync = utils.isAsync();
+  if (exemptAsync && isAsync) {
+    return;
+  }
+  const tagName = /** @type {string} */utils.getPreferredTagName({
+    tagName: 'returns'
+  });
+  if (!tagName) {
+    return;
+  }
+  const tags = utils.getTags(tagName);
+  if (tags.length === 0) {
+    return;
+  }
+  if (tags.length > 1) {
+    report(`Found more than one @${tagName} declaration.`);
+    return;
+  }
+  const [tag] = tags;
+  const type = tag.type.trim();
+
+  // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions
+  if (/asserts\s/v.test(type)) {
+    return;
+  }
+  const returnNever = type === 'never';
+  if (returnNever && utils.hasValueOrExecutorHasNonEmptyResolveValue(false)) {
+    report(`JSDoc @${tagName} declaration set with "never" but return expression is present in function.`);
+    return;
+  }
+  if (noNativeTypes && isAsync && _jsdocUtils.strictNativeTypes.includes(type)) {
+    report('Function is async or otherwise returns a Promise but the return type is a native type.');
+    return;
+  }
+
+  // In case a return value is declared in JSDoc, we also expect one in the code.
+  if (!returnNever && (reportMissingReturnForUndefinedTypes || !utils.mayBeUndefinedTypeTag(tag)) && (tag.type === '' && !utils.hasValueOrExecutorHasNonEmptyResolveValue(exemptAsync) || tag.type !== '' && !utils.hasValueOrExecutorHasNonEmptyResolveValue(exemptAsync, true)) && Boolean(!exemptGenerators || !node || !('generator' in (/** @type {import('../iterateJsdoc.js').Node} */node)) || !(/** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */node).generator)) {
+    report(`JSDoc @${tagName} declaration present but return expression not available in function.`);
+  }
+}, {
+  meta: {
+    docs: {
+      description: 'Requires a return statement in function body if a `@returns` tag is specified in JSDoc comment(and reports if multiple `@returns` tags are present).',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-check.md#repos-sticky-header'
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        exemptAsync: {
+          default: true,
+          description: `By default, functions which return a \`Promise\` that are not
+detected as resolving with a non-\`undefined\` value and \`async\` functions
+(even ones that do not explicitly return a value, as these are returning a
+\`Promise\` implicitly) will be exempted from reporting by this rule.
+If you wish to insist that only \`Promise\`'s which resolve to
+non-\`undefined\` values or \`async\` functions with explicit \`return\`'s will
+be exempted from reporting (i.e., that \`async\` functions can be reported
+if they lack an explicit (non-\`undefined\`) \`return\` when a \`@returns\` is
+present), you can set \`exemptAsync\` to \`false\` on the options object.`,
+          type: 'boolean'
+        },
+        exemptGenerators: {
+          description: `Because a generator might be labeled as having a
+\`IterableIterator\` \`@returns\` value (along with an iterator type
+corresponding to the type of any \`yield\` statements), projects might wish to
+leverage \`@returns\` in generators even without a \`return\` statement. This
+option is therefore \`true\` by default in \`typescript\` mode (in "jsdoc" mode,
+one might be more likely to take advantage of \`@yields\`). Set it to \`false\`
+if you wish for a missing \`return\` to be flagged regardless.`,
+          type: 'boolean'
+        },
+        noNativeTypes: {
+          description: `Whether to check that async functions do not
+indicate they return non-native types. Defaults to \`true\`.`,
+          type: 'boolean'
+        },
+        reportMissingReturnForUndefinedTypes: {
+          default: false,
+          description: `If \`true\` and no return or
+resolve value is found, this setting will even insist that reporting occur
+with \`void\` or \`undefined\` (including as an indicated \`Promise\` type).
+Unlike \`require-returns\`, with this option in the rule, one can
+*discourage* the labeling of \`undefined\` types. Defaults to \`false\`.`,
+          type: 'boolean'
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireReturnsCheck.cjs.map

package/dist/rules/requireReturnsCheck.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireReturnsCheck.cjs","names":["_iterateJsdoc","_interopRequireDefault","require","_jsdocUtils","e","__esModule","default","canSkip","utils","settings","voidingTags","mode","push","hasATag","isConstructor","classHasTag","_default","exports","iterateJsdoc","context","node","report","exemptAsync","exemptGenerators","noNativeTypes","reportMissingReturnForUndefinedTypes","options","isAsync","tagName","getPreferredTagName","tags","getTags","length","tag","type","trim","test","returnNever","hasValueOrExecutorHasNonEmptyResolveValue","strictNativeTypes","includes","mayBeUndefinedTypeTag","Boolean","generator","meta","docs","description","url","schema","additionalProperties","properties","module"],"sources":["../../src/rules/requireReturnsCheck.js"],"sourcesContent":["import iterateJsdoc from '../iterateJsdoc.js';\nimport {\n  strictNativeTypes,\n} from '../jsdocUtils.js';\n\n/**\n * @param {import('../iterateJsdoc.js').Utils} utils\n * @param {import('../iterateJsdoc.js').Settings} settings\n * @returns {boolean}\n */\nconst canSkip = (utils, settings) => {\n  const voidingTags = [\n    // An abstract function is by definition incomplete\n    // so it is perfectly fine if a return is documented but\n    // not present within the function.\n    // A subclass may inherit the doc and implement the\n    // missing return.\n    'abstract',\n    'virtual',\n\n    // A constructor function returns `this` by default, so may be `@returns`\n    //   tag indicating this but no explicit return\n    'class',\n    'constructor',\n    'interface',\n  ];\n\n  if (settings.mode === 'closure') {\n    // Structural Interface in GCC terms, equivalent to @interface tag as far as this rule is concerned\n    voidingTags.push('record');\n  }\n\n  return utils.hasATag(voidingTags) ||\n    utils.isConstructor() ||\n    utils.classHasTag('interface') ||\n    settings.mode === 'closure' && utils.classHasTag('record');\n};\n\nexport default iterateJsdoc(({\n  context,\n  node,\n  report,\n  settings,\n  utils,\n}) => {\n  const {\n    exemptAsync = true,\n    exemptGenerators = settings.mode === 'typescript',\n    noNativeTypes = true,\n    reportMissingReturnForUndefinedTypes = false,\n  } = context.options[0] || {};\n\n  if (canSkip(utils, settings)) {\n    return;\n  }\n\n  const isAsync = utils.isAsync();\n  if (exemptAsync && isAsync) {\n    return;\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 === 0) {\n    return;\n  }\n\n  if (tags.length > 1) {\n    report(`Found more than one @${tagName} declaration.`);\n\n    return;\n  }\n\n  const [\n    tag,\n  ] = tags;\n\n  const type = tag.type.trim();\n\n  // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions\n  if (/asserts\\s/v.test(type)) {\n    return;\n  }\n\n  const returnNever = type === 'never';\n\n  if (returnNever && utils.hasValueOrExecutorHasNonEmptyResolveValue(false)) {\n    report(`JSDoc @${tagName} declaration set with \"never\" but return expression is present in function.`);\n\n    return;\n  }\n\n  if (noNativeTypes && isAsync && strictNativeTypes.includes(type)) {\n    report('Function is async or otherwise returns a Promise but the return type is a native type.');\n    return;\n  }\n\n  // In case a return value is declared in JSDoc, we also expect one in the code.\n  if (\n    !returnNever &&\n    (\n      reportMissingReturnForUndefinedTypes ||\n      !utils.mayBeUndefinedTypeTag(tag)\n    ) &&\n    (tag.type === '' && !utils.hasValueOrExecutorHasNonEmptyResolveValue(\n      exemptAsync,\n    ) ||\n    tag.type !== '' && !utils.hasValueOrExecutorHasNonEmptyResolveValue(\n      exemptAsync,\n      true,\n    )) &&\n    Boolean(\n      !exemptGenerators || !node ||\n      !('generator' in /** @type {import('../iterateJsdoc.js').Node} */ (node)) ||\n      !(/** @type {import('@typescript-eslint/types').TSESTree.FunctionDeclaration} */ (node)).generator,\n    )\n  ) {\n    report(`JSDoc @${tagName} declaration present but return expression not available in function.`);\n  }\n}, {\n  meta: {\n    docs: {\n      description: 'Requires a return statement in function body if a `@returns` tag is specified in JSDoc comment(and reports if multiple `@returns` tags are present).',\n      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-check.md#repos-sticky-header',\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          exemptAsync: {\n            default: true,\n            description: `By default, functions which return a \\`Promise\\` that are not\ndetected as resolving with a non-\\`undefined\\` value and \\`async\\` functions\n(even ones that do not explicitly return a value, as these are returning a\n\\`Promise\\` implicitly) will be exempted from reporting by this rule.\nIf you wish to insist that only \\`Promise\\`'s which resolve to\nnon-\\`undefined\\` values or \\`async\\` functions with explicit \\`return\\`'s will\nbe exempted from reporting (i.e., that \\`async\\` functions can be reported\nif they lack an explicit (non-\\`undefined\\`) \\`return\\` when a \\`@returns\\` is\npresent), you can set \\`exemptAsync\\` to \\`false\\` on the options object.`,\n            type: 'boolean',\n          },\n          exemptGenerators: {\n            description: `Because a generator might be labeled as having a\n\\`IterableIterator\\` \\`@returns\\` value (along with an iterator type\ncorresponding to the type of any \\`yield\\` statements), projects might wish to\nleverage \\`@returns\\` in generators even without a \\`return\\` statement. This\noption is therefore \\`true\\` by default in \\`typescript\\` mode (in \"jsdoc\" mode,\none might be more likely to take advantage of \\`@yields\\`). Set it to \\`false\\`\nif you wish for a missing \\`return\\` to be flagged regardless.`,\n            type: 'boolean',\n          },\n          noNativeTypes: {\n            description: `Whether to check that async functions do not\nindicate they return non-native types. Defaults to \\`true\\`.`,\n            type: 'boolean',\n          },\n          reportMissingReturnForUndefinedTypes: {\n            default: false,\n            description: `If \\`true\\` and no return or\nresolve value is found, this setting will even insist that reporting occur\nwith \\`void\\` or \\`undefined\\` (including as an indicated \\`Promise\\` type).\nUnlike \\`require-returns\\`, with this option in the rule, one can\n*discourage* the labeling of \\`undefined\\` types. Defaults to \\`false\\`.`,\n            type: 'boolean',\n          },\n        },\n        type: 'object',\n      },\n    ],\n    type: 'suggestion',\n  },\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/rules/requireReturnsCheck.d.ts

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

package/dist/rules/requireReturnsDescription.cjs

@@ -0,0 +1,72 @@
+"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 }; }
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  report,
+  utils
+}) => {
+  utils.forEachPreferredTag('returns', (jsdocTag, targetTagName) => {
+    const type = jsdocTag.type && jsdocTag.type.trim();
+    if (['Promise<undefined>', 'Promise<void>', 'undefined', 'void'].includes(type)) {
+      return;
+    }
+    if (!jsdocTag.description.trim()) {
+      report(`Missing JSDoc @${targetTagName} description.`, null, jsdocTag);
+    }
+  });
+}, {
+  contextDefaults: true,
+  meta: {
+    docs: {
+      description: 'Requires that the `@returns` tag has a `description` value (not including `void`/`undefined` type returns).',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-description.md#repos-sticky-header'
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        contexts: {
+          description: `Set this to an array of strings representing the AST context (or an object 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\`).
+
+See the ["AST and Selectors"](../#advanced-ast-and-selectors)
+section of our Advanced docs for more on the expected format.`,
+          items: {
+            anyOf: [{
+              type: 'string'
+            }, {
+              additionalProperties: false,
+              properties: {
+                comment: {
+                  type: 'string'
+                },
+                context: {
+                  type: 'string'
+                }
+              },
+              type: 'object'
+            }]
+          },
+          type: 'array'
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireReturnsDescription.cjs.map

package/dist/rules/requireReturnsDescription.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireReturnsDescription.cjs","names":["_iterateJsdoc","_interopRequireDefault","require","e","__esModule","default","_default","exports","iterateJsdoc","report","utils","forEachPreferredTag","jsdocTag","targetTagName","type","trim","includes","description","contextDefaults","meta","docs","url","schema","additionalProperties","properties","contexts","items","anyOf","comment","context","module"],"sources":["../../src/rules/requireReturnsDescription.js"],"sourcesContent":["import iterateJsdoc from '../iterateJsdoc.js';\n\nexport default iterateJsdoc(({\n  report,\n  utils,\n}) => {\n  utils.forEachPreferredTag('returns', (jsdocTag, targetTagName) => {\n    const type = jsdocTag.type && jsdocTag.type.trim();\n\n    if ([\n      'Promise<undefined>', 'Promise<void>', 'undefined', 'void',\n    ].includes(type)) {\n      return;\n    }\n\n    if (!jsdocTag.description.trim()) {\n      report(`Missing JSDoc @${targetTagName} description.`, null, jsdocTag);\n    }\n  });\n}, {\n  contextDefaults: true,\n  meta: {\n    docs: {\n      description: 'Requires that the `@returns` tag has a `description` value (not including `void`/`undefined` type returns).',\n      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-description.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 (or an object with\noptional \\`context\\` and \\`comment\\` properties) where you wish the 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\\`).\n\nSee the [\"AST and Selectors\"](../#advanced-ast-and-selectors)\nsection of our Advanced docs for more on the expected format.`,\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        },\n        type: 'object',\n      },\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,SAAS,EAAE,CAACC,QAAQ,EAAEC,aAAa,KAAK;IAChE,MAAMC,IAAI,GAAGF,QAAQ,CAACE,IAAI,IAAIF,QAAQ,CAACE,IAAI,CAACC,IAAI,CAAC,CAAC;IAElD,IAAI,CACF,oBAAoB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,CAC3D,CAACC,QAAQ,CAACF,IAAI,CAAC,EAAE;MAChB;IACF;IAEA,IAAI,CAACF,QAAQ,CAACK,WAAW,CAACF,IAAI,CAAC,CAAC,EAAE;MAChCN,MAAM,CAAC,kBAAkBI,aAAa,eAAe,EAAE,IAAI,EAAED,QAAQ,CAAC;IACxE;EACF,CAAC,CAAC;AACJ,CAAC,EAAE;EACDM,eAAe,EAAE,IAAI;EACrBC,IAAI,EAAE;IACJC,IAAI,EAAE;MACJH,WAAW,EAAE,6GAA6G;MAC1HI,GAAG,EAAE;IACP,CAAC;IACDC,MAAM,EAAE,CACN;MACEC,oBAAoB,EAAE,KAAK;MAC3BC,UAAU,EAAE;QACVC,QAAQ,EAAE;UACRR,WAAW,EAAE;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D;UAClDS,KAAK,EAAE;YACLC,KAAK,EAAE,CACL;cACEb,IAAI,EAAE;YACR,CAAC,EACD;cACES,oBAAoB,EAAE,KAAK;cAC3BC,UAAU,EAAE;gBACVI,OAAO,EAAE;kBACPd,IAAI,EAAE;gBACR,CAAC;gBACDe,OAAO,EAAE;kBACPf,IAAI,EAAE;gBACR;cACF,CAAC;cACDA,IAAI,EAAE;YACR,CAAC;UAEL,CAAC;UACDA,IAAI,EAAE;QACR;MACF,CAAC;MACDA,IAAI,EAAE;IACR,CAAC,CACF;IACDA,IAAI,EAAE;EACR;AACF,CAAC,CAAC;AAAAgB,MAAA,CAAAvB,OAAA,GAAAA,OAAA,CAAAF,OAAA","ignoreList":[]}

package/dist/rules/requireReturnsDescription.d.ts

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

package/dist/rules/requireReturnsType.cjs

@@ -0,0 +1,68 @@
+"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 }; }
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  report,
+  utils
+}) => {
+  utils.forEachPreferredTag('returns', (jsdocTag, targetTagName) => {
+    if (!jsdocTag.type) {
+      report(`Missing JSDoc @${targetTagName} type.`, null, jsdocTag);
+    }
+  });
+}, {
+  contextDefaults: true,
+  meta: {
+    docs: {
+      description: 'Requires that `@returns` tag has type value (in curly brackets).',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-type.md#repos-sticky-header'
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        contexts: {
+          description: `Set this to an array of strings representing the AST context (or an object 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\`).
+
+See the ["AST and Selectors"](../#advanced-ast-and-selectors)
+section of our Advanced docs for more on the expected format.`,
+          items: {
+            anyOf: [{
+              type: 'string'
+            }, {
+              additionalProperties: false,
+              properties: {
+                comment: {
+                  type: 'string'
+                },
+                context: {
+                  type: 'string'
+                }
+              },
+              type: 'object'
+            }]
+          },
+          type: 'array'
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireReturnsType.cjs.map

package/dist/rules/requireReturnsType.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireReturnsType.cjs","names":["_iterateJsdoc","_interopRequireDefault","require","e","__esModule","default","_default","exports","iterateJsdoc","report","utils","forEachPreferredTag","jsdocTag","targetTagName","type","contextDefaults","meta","docs","description","url","schema","additionalProperties","properties","contexts","items","anyOf","comment","context","module"],"sources":["../../src/rules/requireReturnsType.js"],"sourcesContent":["import iterateJsdoc from '../iterateJsdoc.js';\n\nexport default iterateJsdoc(({\n  report,\n  utils,\n}) => {\n  utils.forEachPreferredTag('returns', (jsdocTag, targetTagName) => {\n    if (!jsdocTag.type) {\n      report(`Missing JSDoc @${targetTagName} type.`, null, jsdocTag);\n    }\n  });\n}, {\n  contextDefaults: true,\n  meta: {\n    docs: {\n      description: 'Requires that `@returns` tag has type value (in curly brackets).',\n      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-returns-type.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 (or an object with\noptional \\`context\\` and \\`comment\\` properties) where you wish the 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\\`).\n\nSee the [\"AST and Selectors\"](../#advanced-ast-and-selectors)\nsection of our Advanced docs for more on the expected format.`,\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        },\n        type: 'object',\n      },\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,SAAS,EAAE,CAACC,QAAQ,EAAEC,aAAa,KAAK;IAChE,IAAI,CAACD,QAAQ,CAACE,IAAI,EAAE;MAClBL,MAAM,CAAC,kBAAkBI,aAAa,QAAQ,EAAE,IAAI,EAAED,QAAQ,CAAC;IACjE;EACF,CAAC,CAAC;AACJ,CAAC,EAAE;EACDG,eAAe,EAAE,IAAI;EACrBC,IAAI,EAAE;IACJC,IAAI,EAAE;MACJC,WAAW,EAAE,kEAAkE;MAC/EC,GAAG,EAAE;IACP,CAAC;IACDC,MAAM,EAAE,CACN;MACEC,oBAAoB,EAAE,KAAK;MAC3BC,UAAU,EAAE;QACVC,QAAQ,EAAE;UACRL,WAAW,EAAE;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8DAA8D;UAClDM,KAAK,EAAE;YACLC,KAAK,EAAE,CACL;cACEX,IAAI,EAAE;YACR,CAAC,EACD;cACEO,oBAAoB,EAAE,KAAK;cAC3BC,UAAU,EAAE;gBACVI,OAAO,EAAE;kBACPZ,IAAI,EAAE;gBACR,CAAC;gBACDa,OAAO,EAAE;kBACPb,IAAI,EAAE;gBACR;cACF,CAAC;cACDA,IAAI,EAAE;YACR,CAAC;UAEL,CAAC;UACDA,IAAI,EAAE;QACR;MACF,CAAC;MACDA,IAAI,EAAE;IACR,CAAC,CACF;IACDA,IAAI,EAAE;EACR;AACF,CAAC,CAAC;AAAAc,MAAA,CAAArB,OAAA,GAAAA,OAAA,CAAAF,OAAA","ignoreList":[]}

package/dist/rules/requireReturnsType.d.ts

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

package/dist/rules/requireTags.cjs

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _buildForbidRuleDefinition = require("../buildForbidRuleDefinition.cjs");
+var _default = exports.default = (0, _buildForbidRuleDefinition.buildForbidRuleDefinition)({
+  description: 'Requires tags be present, optionally for specific contexts',
+  getContexts(context, report) {
+    // Transformed options to this option in `modifyContext`:
+    if (!context.options[0].contexts) {
+      report('Rule `require-tags` is missing a `tags` option.');
+      return false;
+    }
+    const {
+      contexts
+    } = context.options[0];
+    return contexts;
+  },
+  modifyContext(context) {
+    const tags = /** @type {(string|{tag: string, context: string})[]} */
+    context.options?.[0]?.tags;
+    const cntxts = tags?.map(tag => {
+      const tagName = typeof tag === 'string' ? tag : tag.tag;
+      return {
+        comment: `JsdocBlock:not(*:has(JsdocTag[tag=${tagName}]))`,
+        context: typeof tag === 'string' ? 'any' : tag.context,
+        message: `Missing required tag "${tagName}"`
+      };
+    });
+
+    // Reproduce context object with our own `contexts`
+    const propertyDescriptors = Object.getOwnPropertyDescriptors(context);
+    return Object.create(Object.getPrototypeOf(context), {
+      ...propertyDescriptors,
+      options: {
+        ...propertyDescriptors.options,
+        value: [{
+          contexts: cntxts
+        }]
+      }
+    });
+  },
+  schema: [{
+    additionalProperties: false,
+    properties: {
+      tags: {
+        description: `May be an array of either strings or objects with
+a string \`tag\` property and \`context\` string property.`,
+        items: {
+          anyOf: [{
+            type: 'string'
+          }, {
+            properties: {
+              context: {
+                type: 'string'
+              },
+              tag: {
+                type: 'string'
+              }
+            },
+            type: 'object'
+          }]
+        },
+        type: 'array'
+      }
+    },
+    type: 'object'
+  }],
+  url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-tags.md#repos-sticky-header'
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireTags.cjs.map

package/dist/rules/requireTags.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireTags.cjs","names":["_buildForbidRuleDefinition","require","_default","exports","default","buildForbidRuleDefinition","description","getContexts","context","report","options","contexts","modifyContext","tags","cntxts","map","tag","tagName","comment","message","propertyDescriptors","Object","getOwnPropertyDescriptors","create","getPrototypeOf","value","schema","additionalProperties","properties","items","anyOf","type","url","module"],"sources":["../../src/rules/requireTags.js"],"sourcesContent":["import {\n  buildForbidRuleDefinition,\n} from '../buildForbidRuleDefinition.js';\n\nexport default buildForbidRuleDefinition({\n  description: 'Requires tags be present, optionally for specific contexts',\n  getContexts (context, report) {\n    // Transformed options to this option in `modifyContext`:\n    if (!context.options[0].contexts) {\n      report('Rule `require-tags` is missing a `tags` option.');\n      return false;\n    }\n\n    const {\n      contexts,\n    } = context.options[0];\n\n    return contexts;\n  },\n  modifyContext (context) {\n    const tags = /** @type {(string|{tag: string, context: string})[]} */ (\n      context.options?.[0]?.tags\n    );\n\n    const cntxts = tags?.map((tag) => {\n      const tagName = typeof tag === 'string' ? tag : tag.tag;\n      return {\n        comment: `JsdocBlock:not(*:has(JsdocTag[tag=${\n          tagName\n        }]))`,\n        context: typeof tag === 'string' ? 'any' : tag.context,\n        message: `Missing required tag \"${tagName}\"`,\n      };\n    });\n\n    // Reproduce context object with our own `contexts`\n    const propertyDescriptors = Object.getOwnPropertyDescriptors(context);\n    return Object.create(\n      Object.getPrototypeOf(context),\n      {\n        ...propertyDescriptors,\n        options: {\n          ...propertyDescriptors.options,\n          value: [\n            {\n              contexts: cntxts,\n            },\n          ],\n        },\n      },\n    );\n  },\n  schema: [\n    {\n      additionalProperties: false,\n      properties: {\n        tags: {\n          description: `May be an array of either strings or objects with\na string \\`tag\\` property and \\`context\\` string property.`,\n          items: {\n            anyOf: [\n              {\n                type: 'string',\n              },\n              {\n                properties: {\n                  context: {\n                    type: 'string',\n                  },\n                  tag: {\n                    type: 'string',\n                  },\n                },\n                type: 'object',\n              },\n            ],\n          },\n          type: 'array',\n        },\n      },\n      type: 'object',\n    },\n  ],\n  url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-tags.md#repos-sticky-header',\n});\n"],"mappings":";;;;;;AAAA,IAAAA,0BAAA,GAAAC,OAAA;AAEyC,IAAAC,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAE1B,IAAAC,oDAAyB,EAAC;EACvCC,WAAW,EAAE,4DAA4D;EACzEC,WAAWA,CAAEC,OAAO,EAAEC,MAAM,EAAE;IAC5B;IACA,IAAI,CAACD,OAAO,CAACE,OAAO,CAAC,CAAC,CAAC,CAACC,QAAQ,EAAE;MAChCF,MAAM,CAAC,iDAAiD,CAAC;MACzD,OAAO,KAAK;IACd;IAEA,MAAM;MACJE;IACF,CAAC,GAAGH,OAAO,CAACE,OAAO,CAAC,CAAC,CAAC;IAEtB,OAAOC,QAAQ;EACjB,CAAC;EACDC,aAAaA,CAAEJ,OAAO,EAAE;IACtB,MAAMK,IAAI,GAAG;IACXL,OAAO,CAACE,OAAO,GAAG,CAAC,CAAC,EAAEG,IACvB;IAED,MAAMC,MAAM,GAAGD,IAAI,EAAEE,GAAG,CAAEC,GAAG,IAAK;MAChC,MAAMC,OAAO,GAAG,OAAOD,GAAG,KAAK,QAAQ,GAAGA,GAAG,GAAGA,GAAG,CAACA,GAAG;MACvD,OAAO;QACLE,OAAO,EAAE,qCACPD,OAAO,KACJ;QACLT,OAAO,EAAE,OAAOQ,GAAG,KAAK,QAAQ,GAAG,KAAK,GAAGA,GAAG,CAACR,OAAO;QACtDW,OAAO,EAAE,yBAAyBF,OAAO;MAC3C,CAAC;IACH,CAAC,CAAC;;IAEF;IACA,MAAMG,mBAAmB,GAAGC,MAAM,CAACC,yBAAyB,CAACd,OAAO,CAAC;IACrE,OAAOa,MAAM,CAACE,MAAM,CAClBF,MAAM,CAACG,cAAc,CAAChB,OAAO,CAAC,EAC9B;MACE,GAAGY,mBAAmB;MACtBV,OAAO,EAAE;QACP,GAAGU,mBAAmB,CAACV,OAAO;QAC9Be,KAAK,EAAE,CACL;UACEd,QAAQ,EAAEG;QACZ,CAAC;MAEL;IACF,CACF,CAAC;EACH,CAAC;EACDY,MAAM,EAAE,CACN;IACEC,oBAAoB,EAAE,KAAK;IAC3BC,UAAU,EAAE;MACVf,IAAI,EAAE;QACJP,WAAW,EAAE;AACvB,2DAA2D;QACjDuB,KAAK,EAAE;UACLC,KAAK,EAAE,CACL;YACEC,IAAI,EAAE;UACR,CAAC,EACD;YACEH,UAAU,EAAE;cACVpB,OAAO,EAAE;gBACPuB,IAAI,EAAE;cACR,CAAC;cACDf,GAAG,EAAE;gBACHe,IAAI,EAAE;cACR;YACF,CAAC;YACDA,IAAI,EAAE;UACR,CAAC;QAEL,CAAC;QACDA,IAAI,EAAE;MACR;IACF,CAAC;IACDA,IAAI,EAAE;EACR,CAAC,CACF;EACDC,GAAG,EAAE;AACP,CAAC,CAAC;AAAAC,MAAA,CAAA9B,OAAA,GAAAA,OAAA,CAAAC,OAAA","ignoreList":[]}

package/dist/rules/requireTags.d.ts

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

package/dist/rules/requireTemplate.cjs

@@ -0,0 +1,220 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.cjs"));
+var _jsdoccomment = require("@es-joy/jsdoccomment");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _default = exports.default = (0, _iterateJsdoc.default)(({
+  context,
+  node,
+  report,
+  settings,
+  utils
+}) => {
+  if (utils.avoidDocs()) {
+    return;
+  }
+  const {
+    requireSeparateTemplates = false
+  } = context.options[0] || {};
+  const {
+    mode
+  } = settings;
+  const usedNames = new Set();
+  const tgName = /** @type {string} */utils.getPreferredTagName({
+    tagName: 'template'
+  });
+  if (!tgName) {
+    return;
+  }
+  const templateTags = utils.getTags(tgName);
+  const templateNames = templateTags.flatMap(tag => {
+    return utils.parseClosureTemplateTag(tag);
+  });
+  if (requireSeparateTemplates) {
+    for (const tag of templateTags) {
+      const names = utils.parseClosureTemplateTag(tag);
+      if (names.length > 1) {
+        report(`Missing separate @${tgName} for ${names[1]}`, null, tag);
+      }
+    }
+  }
+
+  /**
+   * @param {import('@typescript-eslint/types').TSESTree.FunctionDeclaration|
+   *   import('@typescript-eslint/types').TSESTree.ClassDeclaration|
+   *   import('@typescript-eslint/types').TSESTree.TSDeclareFunction|
+   *   import('@typescript-eslint/types').TSESTree.TSInterfaceDeclaration|
+   *   import('@typescript-eslint/types').TSESTree.TSTypeAliasDeclaration} aliasDeclaration
+   */
+  const checkTypeParams = aliasDeclaration => {
+    const {
+      params
+      /* c8 ignore next -- Guard */
+    } = aliasDeclaration.typeParameters ?? {
+      /* c8 ignore next -- Guard */
+      params: []
+    };
+    for (const {
+      name: {
+        name
+      }
+    } of params) {
+      usedNames.add(name);
+    }
+    for (const usedName of usedNames) {
+      if (!templateNames.includes(usedName)) {
+        report(`Missing @${tgName} ${usedName}`);
+      }
+    }
+  };
+  const handleTypes = () => {
+    const nde = /** @type {import('@typescript-eslint/types').TSESTree.Node} */
+    node;
+    if (!nde) {
+      return;
+    }
+    switch (nde.type) {
+      case 'ClassDeclaration':
+      case 'FunctionDeclaration':
+      case 'TSDeclareFunction':
+      case 'TSInterfaceDeclaration':
+      case 'TSTypeAliasDeclaration':
+        checkTypeParams(nde);
+        break;
+      case 'ExportDefaultDeclaration':
+        switch (nde.declaration?.type) {
+          case 'ClassDeclaration':
+          case 'FunctionDeclaration':
+          case 'TSInterfaceDeclaration':
+            checkTypeParams(nde.declaration);
+            break;
+        }
+        break;
+      case 'ExportNamedDeclaration':
+        switch (nde.declaration?.type) {
+          case 'ClassDeclaration':
+          case 'FunctionDeclaration':
+          case 'TSDeclareFunction':
+          case 'TSInterfaceDeclaration':
+          case 'TSTypeAliasDeclaration':
+            checkTypeParams(nde.declaration);
+            break;
+        }
+        break;
+    }
+  };
+  const usedNameToTag = new Map();
+
+  /**
+   * @param {import('comment-parser').Spec} potentialTag
+   */
+  const checkForUsedTypes = potentialTag => {
+    let parsedType;
+    try {
+      parsedType = mode === 'permissive' ? (0, _jsdoccomment.tryParse)(/** @type {string} */potentialTag.type) : (0, _jsdoccomment.parse)(/** @type {string} */potentialTag.type, mode);
+    } catch {
+      return;
+    }
+    (0, _jsdoccomment.traverse)(parsedType, nde => {
+      if (nde.type === 'JsdocTypeTypeParameter') {
+        templateNames.push(nde.name.value);
+        return;
+      }
+      if (nde.type === 'JsdocTypeInfer') {
+        templateNames.push(nde.element.value);
+        return;
+      }
+      const {
+        type,
+        value
+      } = /** @type {import('jsdoc-type-pratt-parser').NameResult} */nde;
+      if (type === 'JsdocTypeName' && /^[A-Z]$/v.test(value)) {
+        usedNames.add(value);
+        if (!usedNameToTag.has(value)) {
+          usedNameToTag.set(value, potentialTag);
+        }
+      }
+    });
+  };
+
+  /**
+   * @param {string[]} tagNames
+   */
+  const checkTagsAndTemplates = tagNames => {
+    for (const tagName of tagNames) {
+      const preferredTagName = /** @type {string} */utils.getPreferredTagName({
+        tagName
+      });
+      const matchingTags = utils.getTags(preferredTagName);
+      for (const matchingTag of matchingTags) {
+        checkForUsedTypes(matchingTag);
+      }
+    }
+
+    // Could check against whitelist/blacklist
+    for (const usedName of usedNames) {
+      if (!templateNames.includes(usedName)) {
+        report(`Missing @${tgName} ${usedName}`, null, usedNameToTag.get(usedName));
+      }
+    }
+  };
+  const callbackTags = utils.getTags('callback');
+  const functionTags = utils.getTags('function');
+  if (callbackTags.length || functionTags.length) {
+    checkTagsAndTemplates(['param', 'returns']);
+    return;
+  }
+  const typedefTags = utils.getTags('typedef');
+  if (!typedefTags.length || typedefTags.length >= 2) {
+    handleTypes();
+    return;
+  }
+  const potentialTypedef = typedefTags[0];
+  checkForUsedTypes(potentialTypedef);
+  checkTagsAndTemplates(['property']);
+}, {
+  iterateAllJsdocs: true,
+  meta: {
+    docs: {
+      description: 'Requires `@template` tags be present when type parameters are used.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-template.md#repos-sticky-header'
+    },
+    schema: [{
+      additionalProperties: false,
+      properties: {
+        exemptedBy: {
+          description: `Array of tags (e.g., \`['type']\`) whose presence on the document
+block avoids the need for a \`@template\`. 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'
+        },
+        requireSeparateTemplates: {
+          description: `Requires that each template have its own separate line, i.e., preventing
+templates of this format:
+
+\`\`\`js
+/**
+ * @template T, U, V
+ */
+\`\`\`
+
+Defaults to \`false\`.`,
+          type: 'boolean'
+        }
+      },
+      type: 'object'
+    }],
+    type: 'suggestion'
+  }
+});
+module.exports = exports.default;
+//# sourceMappingURL=requireTemplate.cjs.map