eslint-plugin-jsdoc 48.0.0 → 48.0.1

package/src/rules/noUndefinedTypes.js

@@ -0,0 +1,328 @@
+import iterateJsdoc, {
+  parseComment,
+} from '../iterateJsdoc.js';
+import {
+  getJSDocComment,
+  parse as parseType,
+  traverse,
+  tryParse as tryParseType,
+} from '@es-joy/jsdoccomment';
+
+const extraTypes = [
+  'null', 'undefined', 'void', 'string', 'boolean', 'object',
+  'function', 'symbol',
+  'number', 'bigint', 'NaN', 'Infinity',
+  'any', '*', 'never', 'unknown', 'const',
+  'this', 'true', 'false',
+  'Array', 'Object', 'RegExp', 'Date', 'Function',
+];
+
+const typescriptGlobals = [
+  // https://www.typescriptlang.org/docs/handbook/utility-types.html
+  'Awaited',
+  'Partial',
+  'Required',
+  'Readonly',
+  'Record',
+  'Pick',
+  'Omit',
+  'Exclude',
+  'Extract',
+  'NonNullable',
+  'Parameters',
+  'ConstructorParameters',
+  'ReturnType',
+  'InstanceType',
+  'ThisParameterType',
+  'OmitThisParameter',
+  'ThisType',
+  'Uppercase',
+  'Lowercase',
+  'Capitalize',
+  'Uncapitalize',
+];
+
+/**
+ * @param {string|false|undefined} [str]
+ * @returns {undefined|string|false}
+ */
+const stripPseudoTypes = (str) => {
+  return str && str.replace(/(?:\.|<>|\.<>|\[\])$/u, '');
+};
+
+export default iterateJsdoc(({
+  context,
+  node,
+  report,
+  settings,
+  sourceCode,
+  utils,
+}) => {
+  const {
+    scopeManager,
+  } = sourceCode;
+
+  // When is this ever `null`?
+  const globalScope = /** @type {import('eslint').Scope.Scope} */ (
+    scopeManager.globalScope
+  );
+
+  const
+    /**
+     * @type {{
+     *   definedTypes: string[],
+     *   disableReporting: boolean,
+     *   markVariablesAsUsed: boolean
+     * }}
+     */ {
+      definedTypes = [],
+      disableReporting = false,
+      markVariablesAsUsed = true,
+    } = context.options[0] || {};
+
+  /** @type {(string|undefined)[]} */
+  let definedPreferredTypes = [];
+  const {
+    preferredTypes,
+    structuredTags,
+    mode,
+  } = settings;
+  if (Object.keys(preferredTypes).length) {
+    definedPreferredTypes = /** @type {string[]} */ (Object.values(preferredTypes).map((preferredType) => {
+      if (typeof preferredType === 'string') {
+        // May become an empty string but will be filtered out below
+        return stripPseudoTypes(preferredType);
+      }
+
+      if (!preferredType) {
+        return undefined;
+      }
+
+      if (typeof preferredType !== 'object') {
+        utils.reportSettings(
+          'Invalid `settings.jsdoc.preferredTypes`. Values must be falsy, a string, or an object.',
+        );
+      }
+
+      return stripPseudoTypes(preferredType.replacement);
+    })
+      .filter(Boolean));
+  }
+
+  const typedefDeclarations = sourceCode.getAllComments()
+    .filter((comment) => {
+      return (/^\*\s/u).test(comment.value);
+    })
+    .map((commentNode) => {
+      return parseComment(commentNode, '');
+    })
+    .flatMap((doc) => {
+      return doc.tags.filter(({
+        tag,
+      }) => {
+        return utils.isNamepathDefiningTag(tag);
+      });
+    })
+    .map((tag) => {
+      return tag.name;
+    });
+
+  const ancestorNodes = [];
+
+  let currentNode = node;
+  // No need for Program node?
+  while (currentNode?.parent) {
+    ancestorNodes.push(currentNode);
+    currentNode = currentNode.parent;
+  }
+
+  /**
+   * @param {import('eslint').Rule.Node} ancestorNode
+   * @returns {import('comment-parser').Spec[]}
+   */
+  const getTemplateTags = function (ancestorNode) {
+    const commentNode = getJSDocComment(sourceCode, ancestorNode, settings);
+    if (!commentNode) {
+      return [];
+    }
+
+    const jsdoc = parseComment(commentNode, '');
+
+    return jsdoc.tags.filter((tag) => {
+      return tag.tag === 'template';
+    });
+  };
+
+  // `currentScope` may be `null` or `Program`, so in such a case,
+  //  we look to present tags instead
+  const templateTags = ancestorNodes.length ?
+    ancestorNodes.flatMap((ancestorNode) => {
+      return getTemplateTags(ancestorNode);
+    }) :
+    utils.getPresentTags([
+      'template',
+    ]);
+
+  const closureGenericTypes = templateTags.flatMap((tag) => {
+    return utils.parseClosureTemplateTag(tag);
+  });
+
+  // In modules, including Node, there is a global scope at top with the
+  //  Program scope inside
+  const cjsOrESMScope = globalScope.childScopes[0]?.block?.type === 'Program';
+
+  const allDefinedTypes = new Set(globalScope.variables.map(({
+    name,
+  }) => {
+    return name;
+  })
+
+    // If the file is a module, concat the variables from the module scope.
+    .concat(
+      cjsOrESMScope ?
+        globalScope.childScopes.flatMap(({
+          variables,
+        }) => {
+          return variables;
+        }).map(({
+          name,
+        }) => {
+          return name;
+        /* c8 ignore next */
+        }) : [],
+    )
+    .concat(extraTypes)
+    .concat(typedefDeclarations)
+    .concat(definedTypes)
+    .concat(/** @type {string[]} */ (definedPreferredTypes))
+    .concat(
+      settings.mode === 'jsdoc' ?
+        [] :
+        [
+          ...settings.mode === 'typescript' ? typescriptGlobals : [],
+          ...closureGenericTypes,
+        ],
+    ));
+
+  /**
+   * @typedef {{
+   *   parsedType: import('jsdoc-type-pratt-parser').RootResult;
+   *   tag: import('comment-parser').Spec|import('@es-joy/jsdoccomment').JsdocInlineTagNoType & {
+   *     line?: import('../iterateJsdoc.js').Integer
+   *   }
+   * }} TypeAndTagInfo
+   */
+
+  /**
+   * @param {string} propertyName
+   * @returns {(tag: (import('@es-joy/jsdoccomment').JsdocInlineTagNoType & {
+   *     name?: string,
+   *     type?: string,
+   *     line?: import('../iterateJsdoc.js').Integer
+   *   })|import('comment-parser').Spec & {
+   *     namepathOrURL?: string
+   *   }
+   * ) => undefined|TypeAndTagInfo}
+   */
+  const tagToParsedType = (propertyName) => {
+    return (tag) => {
+      try {
+        const potentialType = tag[
+          /** @type {"type"|"name"|"namepathOrURL"} */ (propertyName)
+        ];
+        return {
+          parsedType: mode === 'permissive' ?
+            tryParseType(/** @type {string} */ (potentialType)) :
+            parseType(/** @type {string} */ (potentialType), mode),
+          tag,
+        };
+      } catch {
+        return undefined;
+      }
+    };
+  };
+
+  const typeTags = utils.filterTags(({
+    tag,
+  }) => {
+    return utils.tagMightHaveTypePosition(tag) && (tag !== 'suppress' || settings.mode !== 'closure');
+  }).map(tagToParsedType('type'));
+
+  const namepathReferencingTags = utils.filterTags(({
+    tag,
+  }) => {
+    return utils.isNamepathReferencingTag(tag);
+  }).map(tagToParsedType('name'));
+
+  const namepathOrUrlReferencingTags = utils.filterAllTags(({
+    tag,
+  }) => {
+    return utils.isNamepathOrUrlReferencingTag(tag);
+  }).map(tagToParsedType('namepathOrURL'));
+
+  const tagsWithTypes = /** @type {TypeAndTagInfo[]} */ ([
+    ...typeTags,
+    ...namepathReferencingTags,
+    ...namepathOrUrlReferencingTags,
+    // Remove types which failed to parse
+  ].filter(Boolean));
+
+  for (const {
+    tag,
+    parsedType,
+  } of tagsWithTypes) {
+    traverse(parsedType, (nde) => {
+      const {
+        type,
+        value,
+      } = /** @type {import('jsdoc-type-pratt-parser').NameResult} */ (nde);
+
+      if (type === 'JsdocTypeName') {
+        const structuredTypes = structuredTags[tag.tag]?.type;
+        if (!allDefinedTypes.has(value) &&
+          (!Array.isArray(structuredTypes) || !structuredTypes.includes(value))
+        ) {
+          if (!disableReporting) {
+            report(`The type '${value}' is undefined.`, null, tag);
+          }
+        } else if (markVariablesAsUsed && !extraTypes.includes(value)) {
+          if (sourceCode.markVariableAsUsed) {
+            sourceCode.markVariableAsUsed(value);
+          /* c8 ignore next 3 */
+          } else {
+            context.markVariableAsUsed(value);
+          }
+        }
+      }
+    });
+  }
+}, {
+  iterateAllJsdocs: true,
+  meta: {
+    docs: {
+      description: 'Checks that types in jsdoc comments are defined.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/no-undefined-types.md#repos-sticky-header',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          definedTypes: {
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+          disableReporting: {
+            type: 'boolean',
+          },
+          markVariablesAsUsed: {
+            type: 'boolean',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+});

package/src/rules/requireAsteriskPrefix.js

@@ -0,0 +1,189 @@
+import iterateJsdoc from '../iterateJsdoc.js';
+
+export default iterateJsdoc(({
+  context,
+  jsdoc,
+  utils,
+  indent,
+}) => {
+  const [
+    defaultRequireValue = 'always',
+    {
+      tags: tagMap = {},
+    } = {},
+  ] = context.options;
+
+  const {
+    source,
+  } = jsdoc;
+
+  const always = defaultRequireValue === 'always';
+  const never = defaultRequireValue === 'never';
+
+  /** @type {string} */
+  let currentTag;
+  source.some(({
+    number,
+    tokens,
+  }) => {
+    const {
+      delimiter,
+      tag,
+      end,
+      description,
+    } = tokens;
+
+    /**
+     * @returns {void}
+     */
+    const neverFix = () => {
+      tokens.delimiter = '';
+      tokens.postDelimiter = '';
+    };
+
+    /**
+     * @param {string} checkValue
+     * @returns {boolean}
+     */
+    const checkNever = (checkValue) => {
+      if (delimiter && delimiter !== '/**' && (
+        never && !tagMap.always?.includes(checkValue) ||
+        tagMap.never?.includes(checkValue)
+      )) {
+        utils.reportJSDoc('Expected JSDoc line to have no prefix.', {
+          column: 0,
+          line: number,
+        }, neverFix);
+
+        return true;
+      }
+
+      return false;
+    };
+
+    /**
+     * @returns {void}
+     */
+    const alwaysFix = () => {
+      if (!tokens.start) {
+        tokens.start = indent + ' ';
+      }
+
+      tokens.delimiter = '*';
+      tokens.postDelimiter = tag || description ? ' ' : '';
+    };
+
+    /**
+     * @param {string} checkValue
+     * @returns {boolean}
+     */
+    const checkAlways = (checkValue) => {
+      if (
+        !delimiter && (
+          always && !tagMap.never?.includes(checkValue) ||
+          tagMap.always?.includes(checkValue)
+        )
+      ) {
+        utils.reportJSDoc('Expected JSDoc line to have the prefix.', {
+          column: 0,
+          line: number,
+        }, alwaysFix);
+
+        return true;
+      }
+
+      return false;
+    };
+
+    if (tag) {
+      // Remove at sign
+      currentTag = tag.slice(1);
+    }
+
+    if (
+      // If this is the end but has a tag, the delimiter will also be
+      //  populated and will be safely ignored later
+      end && !tag
+    ) {
+      return false;
+    }
+
+    if (!currentTag) {
+      if (tagMap.any?.includes('*description')) {
+        return false;
+      }
+
+      if (checkNever('*description')) {
+        return true;
+      }
+
+      if (checkAlways('*description')) {
+        return true;
+      }
+
+      return false;
+    }
+
+    if (tagMap.any?.includes(currentTag)) {
+      return false;
+    }
+
+    if (checkNever(currentTag)) {
+      return true;
+    }
+
+    if (checkAlways(currentTag)) {
+      return true;
+    }
+
+    return false;
+  });
+}, {
+  iterateAllJsdocs: true,
+  meta: {
+    docs: {
+      description:
+        'Requires that each JSDoc line starts with an `*`.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-asterisk-prefix.md#repos-sticky-header',
+    },
+    fixable: 'code',
+    schema: [
+      {
+        enum: [
+          'always', 'never', 'any',
+        ],
+        type: 'string',
+      },
+      {
+        additionalProperties: false,
+        properties: {
+          tags: {
+            properties: {
+              always: {
+                items: {
+                  type: 'string',
+                },
+                type: 'array',
+              },
+              any: {
+                items: {
+                  type: 'string',
+                },
+                type: 'array',
+              },
+              never: {
+                items: {
+                  type: 'string',
+                },
+                type: 'array',
+              },
+            },
+            type: 'object',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'layout',
+  },
+});

package/src/rules/requireDescription.js

@@ -0,0 +1,161 @@
+import iterateJsdoc from '../iterateJsdoc.js';
+
+/**
+ * @param {string} description
+ * @returns {import('../iterateJsdoc.js').Integer}
+ */
+const checkDescription = (description) => {
+  return description
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .length;
+};
+
+export default iterateJsdoc(({
+  jsdoc,
+  report,
+  utils,
+  context,
+}) => {
+  if (utils.avoidDocs()) {
+    return;
+  }
+
+  const {
+    descriptionStyle = 'body',
+  } = context.options[0] || {};
+
+  let targetTagName = utils.getPreferredTagName({
+    // We skip reporting except when `@description` is essential to the rule,
+    //  so user can block the tag and still meaningfully use this rule
+    //  even if the tag is present (and `check-tag-names` is the one to
+    //  normally report the fact that it is blocked but present)
+    skipReportingBlockedTag: descriptionStyle !== 'tag',
+    tagName: 'description',
+  });
+  if (!targetTagName) {
+    return;
+  }
+
+  const isBlocked = typeof targetTagName === 'object' && 'blocked' in targetTagName && targetTagName.blocked;
+  if (isBlocked) {
+    targetTagName = /** @type {{blocked: true; tagName: string;}} */ (
+      targetTagName
+    ).tagName;
+  }
+
+  if (descriptionStyle !== 'tag') {
+    const {
+      description,
+    } = utils.getDescription();
+    if (checkDescription(description || '')) {
+      return;
+    }
+
+    if (descriptionStyle === 'body') {
+      const descTags = utils.getPresentTags([
+        'desc', 'description',
+      ]);
+      if (descTags.length) {
+        const [
+          {
+            tag: tagName,
+          },
+        ] = descTags;
+        report(`Remove the @${tagName} tag to leave a plain block description or add additional description text above the @${tagName} line.`);
+      } else {
+        report('Missing JSDoc block description.');
+      }
+
+      return;
+    }
+  }
+
+  const functionExamples = isBlocked ?
+    [] :
+    jsdoc.tags.filter(({
+      tag,
+    }) => {
+      return tag === targetTagName;
+    });
+
+  if (!functionExamples.length) {
+    report(
+      descriptionStyle === 'any' ?
+        `Missing JSDoc block description or @${targetTagName} declaration.` :
+        `Missing JSDoc @${targetTagName} declaration.`,
+    );
+
+    return;
+  }
+
+  for (const example of functionExamples) {
+    if (!checkDescription(`${example.name} ${utils.getTagDescription(example)}`)) {
+      report(`Missing JSDoc @${targetTagName} description.`, null, example);
+    }
+  }
+}, {
+  contextDefaults: true,
+  meta: {
+    docs: {
+      description: 'Requires that all functions have a description.',
+      url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/require-description.md#repos-sticky-header',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          checkConstructors: {
+            default: true,
+            type: 'boolean',
+          },
+          checkGetters: {
+            default: true,
+            type: 'boolean',
+          },
+          checkSetters: {
+            default: true,
+            type: 'boolean',
+          },
+          contexts: {
+            items: {
+              anyOf: [
+                {
+                  type: 'string',
+                },
+                {
+                  additionalProperties: false,
+                  properties: {
+                    comment: {
+                      type: 'string',
+                    },
+                    context: {
+                      type: 'string',
+                    },
+                  },
+                  type: 'object',
+                },
+              ],
+            },
+            type: 'array',
+          },
+          descriptionStyle: {
+            enum: [
+              'body', 'tag', 'any',
+            ],
+            type: 'string',
+          },
+          exemptedBy: {
+            items: {
+              type: 'string',
+            },
+            type: 'array',
+          },
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+});