eslint-plugin-jsdoc 46.4.4 → 46.4.6

package/dist/jsdocUtils.d.ts

@@ -0,0 +1,421 @@
+declare namespace _default {
+    export { comparePaths };
+    export { dropPathSegmentQuotes };
+    export { enforcedContexts };
+    export { exemptSpeciaMethods };
+    export { flattenRoots };
+    export { getAllTags };
+    export { getContextObject };
+    export { getFunctionParameterNames };
+    export { getIndent };
+    export { getJsdocTagsDeep };
+    export { getPreferredTagName };
+    export { getRegexFromString };
+    export { getTagsByType };
+    export { getTagStructureForMode };
+    export { hasATag };
+    export { hasParams };
+    export { hasReturnValue };
+    export { hasTag };
+    export { hasThrowValue };
+    export { hasValueOrExecutorHasNonEmptyResolveValue };
+    export { hasYieldValue };
+    export { isConstructor };
+    export { isGetter };
+    export { isNamepathDefiningTag };
+    export { isNamepathOrUrlReferencingTag };
+    export { isNamepathReferencingTag };
+    export { isSetter };
+    export { isValidTag };
+    export { mayBeUndefinedTypeTag };
+    export { overrideTagStructure };
+    export { parseClosureTemplateTag };
+    export { pathDoesNotBeginWith };
+    export { setTagStructure };
+    export { tagMightHaveEitherTypeOrNamePosition };
+    export { tagMightHaveNamepath };
+    export { tagMightHaveNamePosition };
+    export { tagMightHaveTypePosition };
+    export { tagMissingRequiredTypeOrNamepath };
+    export { tagMustHaveNamePosition };
+    export { tagMustHaveTypePosition };
+}
+export default _default;
+export type Integer = number;
+export type ESTreeOrTypeScriptNode = import('./utils/hasReturnValue.js').ESTreeOrTypeScriptNode;
+export type ParserMode = "jsdoc" | "typescript" | "closure" | "permissive";
+export type ParamCommon = undefined | string | {
+    name: Integer;
+    restElement: boolean;
+} | {
+    isRestProperty: boolean | undefined;
+    name: string;
+    restElement: boolean;
+} | {
+    name: string;
+    restElement: boolean;
+};
+export type ParamNameInfo = ParamCommon | [
+    string | undefined,
+    (FlattendRootInfo & {
+        annotationParamName?: string;
+    })
+] | [string, string[] | ParamInfo[]];
+export type FlattendRootInfo = {
+    hasPropertyRest: boolean;
+    hasRestElement: boolean;
+    names: string[];
+    rests: boolean[];
+};
+export type NestedParamInfo = [string, (string[] | ParamInfo[])];
+export type ParamInfo = ParamCommon | [
+    string | undefined,
+    (FlattendRootInfo & {
+        annotationParamName?: string;
+    })
+] | [string, string[] | ParamInfo[]];
+/**
+ * Given a nested array of property names, reduce them to a single array,
+ * appending the name of the root element along the way if present.
+ */
+export type FlattenRoots = (params: ParamInfo[], root?: string | undefined) => FlattendRootInfo;
+export type DefaultContexts = true | string[];
+export type TagNamePreference = {
+    [key: string]: string | false | {
+        message: string;
+        replacement?: string | undefined;
+    };
+};
+export type PathDoesNotBeginWith = (name: string, otherPathName: string) => boolean;
+/**
+ * @param {string} name
+ * @returns {(otherPathName: string) => boolean}
+ */
+declare function comparePaths(name: string): (otherPathName: string) => boolean;
+/**
+ * Since path segments may be unquoted (if matching a reserved word,
+ * identifier or numeric literal) or single or double quoted, in either
+ * the `@param` or in source, we need to strip the quotes to give a fair
+ * comparison.
+ * @param {string} str
+ * @returns {string}
+ */
+declare function dropPathSegmentQuotes(str: string): string;
+/**
+ * @typedef {true|string[]} DefaultContexts
+ */
+/**
+ * Checks user option for `contexts` array, defaulting to
+ * contexts designated by the rule. Returns an array of
+ * ESTree AST types, indicating allowable contexts.
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {DefaultContexts|undefined} defaultContexts
+ * @param {{
+ *   contexts?: import('./iterateJsdoc.js').Context[]
+ * }} settings
+ * @returns {string[]}
+ */
+declare function enforcedContexts(context: import('eslint').Rule.RuleContext, defaultContexts: DefaultContexts | undefined, settings: {
+    contexts?: import("./iterateJsdoc.js").Context[] | undefined;
+}): string[];
+/**
+ * @param {import('./iterateJsdoc.js').JsdocBlockWithInline} jsdoc
+ * @param {import('eslint').Rule.Node|null} node
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {import('json-schema').JSONSchema4} schema
+ * @returns {boolean}
+ */
+declare function exemptSpeciaMethods(jsdoc: import('./iterateJsdoc.js').JsdocBlockWithInline, node: import('eslint').Rule.Node | null, context: import('eslint').Rule.RuleContext, schema: any): boolean;
+/**
+ * @typedef {undefined|string|{
+ *   name: Integer,
+ *   restElement: boolean
+ * }|{
+ *   isRestProperty: boolean|undefined,
+ *   name: string,
+ *   restElement: boolean
+ * }|{
+ *   name: string,
+ *   restElement: boolean
+ * }} ParamCommon
+ */
+/**
+ * @typedef {ParamCommon|[string|undefined, (FlattendRootInfo & {
+ *   annotationParamName?: string,
+ * })]|NestedParamInfo} ParamNameInfo
+ */
+/**
+ * @typedef {{
+ *   hasPropertyRest: boolean,
+ *   hasRestElement: boolean,
+ *   names: string[],
+ *   rests: boolean[],
+ * }} FlattendRootInfo
+ */
+/**
+ * @typedef {[string, (string[]|ParamInfo[])]} NestedParamInfo
+ */
+/**
+ * @typedef {ParamCommon|
+ * [string|undefined, (FlattendRootInfo & {
+ *   annotationParamName?: string
+ * })]|
+ * NestedParamInfo} ParamInfo
+ */
+/**
+ * Given a nested array of property names, reduce them to a single array,
+ * appending the name of the root element along the way if present.
+ * @callback FlattenRoots
+ * @param {ParamInfo[]} params
+ * @param {string} [root]
+ * @returns {FlattendRootInfo}
+ */
+/** @type {FlattenRoots} */
+declare const flattenRoots: FlattenRoots;
+/**
+ * Get all tags, inline tags and inline tags in tags
+ * @param {import('./iterateJsdoc.js').JsdocBlockWithInline} jsdoc
+ * @returns {(import('comment-parser').Spec|
+ *   import('@es-joy/jsdoccomment').JsdocInlineTagNoType)[]}
+ */
+declare function getAllTags(jsdoc: import('./iterateJsdoc.js').JsdocBlockWithInline): (import('comment-parser').Spec | import('@es-joy/jsdoccomment').JsdocInlineTagNoType)[];
+/**
+ * @param {import('./iterateJsdoc.js').Context[]} contexts
+ * @param {import('./iterateJsdoc.js').CheckJsdoc} checkJsdoc
+ * @param {import('@es-joy/jsdoccomment').CommentHandler} [handler]
+ * @returns {import('eslint').Rule.RuleListener}
+ */
+declare function getContextObject(contexts: import('./iterateJsdoc.js').Context[], checkJsdoc: import('./iterateJsdoc.js').CheckJsdoc, handler?: import("@es-joy/jsdoccomment").CommentHandler | undefined): import('eslint').Rule.RuleListener;
+/**
+ * @param {ESTreeOrTypeScriptNode|null} functionNode
+ * @param {boolean} [checkDefaultObjects]
+ * @throws {Error}
+ * @returns {ParamNameInfo[]}
+ */
+declare function getFunctionParameterNames(functionNode: ESTreeOrTypeScriptNode | null, checkDefaultObjects?: boolean | undefined): ParamNameInfo[];
+/**
+ * @param {import('eslint').SourceCode|{
+ *   text: string
+ * }} sourceCode
+ * @returns {string}
+ */
+declare function getIndent(sourceCode: import('eslint').SourceCode | {
+    text: string;
+}): string;
+/**
+ * Gets all names of the target type, including those that refer to a path, e.g.
+ * `foo` or `foo.bar`.
+ * @param {import('comment-parser').Block} jsdoc
+ * @param {string} targetTagName
+ * @returns {{
+ *   idx: Integer,
+ *   name: string,
+ *   type: string
+ * }[]}
+ */
+declare function getJsdocTagsDeep(jsdoc: import('comment-parser').Block, targetTagName: string): {
+    idx: Integer;
+    name: string;
+    type: string;
+}[];
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {ParserMode|undefined} mode
+ * @param {string} name
+ * @param {TagNamePreference} tagPreference
+ * @returns {string|false|{
+ *   message: string;
+ *   replacement?: string|undefined;
+ * }}
+ */
+declare function getPreferredTagName(context: import('eslint').Rule.RuleContext, mode: ParserMode | undefined, name: string, tagPreference?: TagNamePreference): string | false | {
+    message: string;
+    replacement?: string | undefined;
+};
+/**
+ * @param {string} regexString
+ * @param {string} [requiredFlags]
+ * @returns {RegExp}
+ */
+declare function getRegexFromString(regexString: string, requiredFlags?: string | undefined): RegExp;
+/**
+ * @typedef {{
+ *   [key: string]: false|string|
+ *     {message: string, replacement?: string}
+ * }} TagNamePreference
+ */
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {ParserMode|undefined} mode
+ * @param {import('comment-parser').Spec[]} tags
+ * @returns {{
+ *   tagsWithNames: import('comment-parser').Spec[],
+ *   tagsWithoutNames: import('comment-parser').Spec[]
+ * }}
+ */
+declare function getTagsByType(context: import('eslint').Rule.RuleContext, mode: ParserMode | undefined, tags: import('comment-parser').Spec[]): {
+    tagsWithNames: import('comment-parser').Spec[];
+    tagsWithoutNames: import('comment-parser').Spec[];
+};
+/**
+ * @param {ParserMode} mode
+ * @param {import('./iterateJsdoc.js').StructuredTags} structuredTags
+ * @returns {import('./getDefaultTagStructureForMode.js').TagStructure}
+ */
+declare function getTagStructureForMode(mode: ParserMode, structuredTags: import('./iterateJsdoc.js').StructuredTags): import('./getDefaultTagStructureForMode.js').TagStructure;
+/**
+ * @param {import('./iterateJsdoc.js').JsdocBlockWithInline} jsdoc
+ * @param {string[]} targetTagNames
+ * @returns {boolean}
+ */
+declare function hasATag(jsdoc: import('./iterateJsdoc.js').JsdocBlockWithInline, targetTagNames: string[]): boolean;
+/**
+ * @param {ESTreeOrTypeScriptNode} functionNode
+ * @returns {Integer}
+ */
+declare function hasParams(functionNode: ESTreeOrTypeScriptNode): Integer;
+import { hasReturnValue } from './utils/hasReturnValue.js';
+/**
+ * @param {import('./iterateJsdoc.js').JsdocBlockWithInline} jsdoc
+ * @param {string} targetTagName
+ * @returns {boolean}
+ */
+declare function hasTag(jsdoc: import('./iterateJsdoc.js').JsdocBlockWithInline, targetTagName: string): boolean;
+/**
+ * Checks if a node has a throws statement.
+ * @param {ESTreeOrTypeScriptNode|null|undefined} node
+ * @param {boolean} [innerFunction]
+ * @returns {boolean}
+ */
+declare function hasThrowValue(node: ESTreeOrTypeScriptNode | null | undefined, innerFunction?: boolean | undefined): boolean;
+import { hasValueOrExecutorHasNonEmptyResolveValue } from './utils/hasReturnValue.js';
+/**
+ * Checks if a node has a return statement. Void return does not count.
+ * @param {ESTreeOrTypeScriptNode} node
+ * @param {boolean} [checkYieldReturnValue]
+ * @returns {boolean}
+ */
+declare function hasYieldValue(node: ESTreeOrTypeScriptNode, checkYieldReturnValue?: boolean | undefined): boolean;
+/**
+ * @param {import('eslint').Rule.Node|null} node
+ * @returns {boolean}
+ */
+declare function isConstructor(node: import('eslint').Rule.Node | null): boolean;
+/**
+ * @param {import('eslint').Rule.Node|null} node
+ * @returns {boolean}
+ */
+declare function isGetter(node: import('eslint').Rule.Node | null): boolean;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean}
+ */
+declare function isNamepathDefiningTag(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean}
+ */
+declare function isNamepathOrUrlReferencingTag(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean}
+ */
+declare function isNamepathReferencingTag(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean;
+/**
+ * @param {import('eslint').Rule.Node|null} node
+ * @returns {boolean}
+ */
+declare function isSetter(node: import('eslint').Rule.Node | null): boolean;
+/**
+ * @param {import('eslint').Rule.RuleContext} context
+ * @param {ParserMode|undefined} mode
+ * @param {string} name
+ * @param {string[]} definedTags
+ * @returns {boolean}
+ */
+declare function isValidTag(context: import('eslint').Rule.RuleContext, mode: ParserMode | undefined, name: string, definedTags: string[]): boolean;
+/**
+ * Checks if the JSDoc comment has an undefined type.
+ * @param {import('comment-parser').Spec|null|undefined} tag
+ *   the tag which should be checked.
+ * @param {ParserMode} mode
+ * @returns {boolean}
+ *   true in case a defined type is undeclared; otherwise false.
+ */
+declare function mayBeUndefinedTypeTag(tag: import('comment-parser').Spec | null | undefined, mode: ParserMode): boolean;
+/**
+ * @param {import('./iterateJsdoc.js').StructuredTags} structuredTags
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {void}
+ */
+declare function overrideTagStructure(structuredTags: import('./iterateJsdoc.js').StructuredTags, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): void;
+/**
+ * @param {string} tag
+ */
+/**
+ * Parses GCC Generic/Template types
+ * @see {@link https://github.com/google/closure-compiler/wiki/Generic-Types}
+ * @see {@link https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html#template}
+ * @param {import('comment-parser').Spec} tag
+ * @returns {string[]}
+ */
+declare function parseClosureTemplateTag(tag: import('comment-parser').Spec): string[];
+/**
+ * @callback PathDoesNotBeginWith
+ * @param {string} name
+ * @param {string} otherPathName
+ * @returns {boolean}
+ */
+/** @type {PathDoesNotBeginWith} */
+declare const pathDoesNotBeginWith: PathDoesNotBeginWith;
+/**
+ * @param {ParserMode} mode
+ * @returns {void}
+ */
+declare function setTagStructure(mode: ParserMode): void;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean}
+ */
+declare function tagMightHaveEitherTypeOrNamePosition(tag: string, tagMap: import('./getDefaultTagStructureForMode.js').TagStructure): boolean;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean}
+ */
+declare function tagMightHaveNamepath(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean}
+ */
+declare function tagMightHaveNamePosition(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean|string}
+ */
+declare function tagMightHaveTypePosition(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean | string;
+/**
+ * @param {import('comment-parser').Spec} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean|undefined}
+ */
+declare function tagMissingRequiredTypeOrNamepath(tag: import('comment-parser').Spec, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean | undefined;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean|undefined}
+ */
+declare function tagMustHaveNamePosition(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean | undefined;
+/**
+ * @param {string} tag
+ * @param {import('./getDefaultTagStructureForMode.js').TagStructure} tagMap
+ * @returns {boolean|undefined}
+ */
+declare function tagMustHaveTypePosition(tag: string, tagMap?: import('./getDefaultTagStructureForMode.js').TagStructure): boolean | undefined;
+//# sourceMappingURL=jsdocUtils.d.ts.map

package/dist/jsdocUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdocUtils.d.ts","sourceRoot":"","sources":["../src/jsdocUtils.js"],"names":[],"mappings":"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"}

package/dist/jsdocUtils.js

@@ -4,10 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _getDefaultTagStructureForMode = _interopRequireDefault(require("./getDefaultTagStructureForMode"));
-var _tagNames = require("./tagNames");
-var _hasReturnValue = require("./utils/hasReturnValue");
-var _WarnSettings = _interopRequireDefault(require("./WarnSettings"));
+var _getDefaultTagStructureForMode = _interopRequireDefault(require("./getDefaultTagStructureForMode.js"));
+var _tagNames = require("./tagNames.js");
+var _hasReturnValue = require("./utils/hasReturnValue.js");
+var _WarnSettings = _interopRequireDefault(require("./WarnSettings.js"));
 var _jsdoccomment = require("@es-joy/jsdoccomment");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
@@ -200,7 +200,7 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
       var _typeAnnotation$typeA;
       const typeAnnotation = hasLeftTypeAnnotation ? /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */param.left.typeAnnotation : /** @type {import('@typescript-eslint/types').TSESTree.Identifier|import('@typescript-eslint/types').TSESTree.ObjectPattern} */
       param.typeAnnotation;
-      if ((typeAnnotation === null || typeAnnotation === void 0 ? void 0 : (_typeAnnotation$typeA = typeAnnotation.typeAnnotation) === null || _typeAnnotation$typeA === void 0 ? void 0 : _typeAnnotation$typeA.type) === 'TSTypeLiteral') {
+      if ((typeAnnotation === null || typeAnnotation === void 0 || (_typeAnnotation$typeA = typeAnnotation.typeAnnotation) === null || _typeAnnotation$typeA === void 0 ? void 0 : _typeAnnotation$typeA.type) === 'TSTypeLiteral') {
         const propertyNames = typeAnnotation.typeAnnotation.members.map(member => {
           return getPropertiesFromPropertySignature( /** @type {import('@typescript-eslint/types').TSESTree.TSPropertySignature} */
           member);
@@ -1179,7 +1179,7 @@ const getIndent = sourceCode => {
  */
 const isConstructor = node => {
   var _node$parent;
-  return (node === null || node === void 0 ? void 0 : node.type) === 'MethodDefinition' && node.kind === 'constructor' || /** @type {import('@typescript-eslint/types').TSESTree.MethodDefinition} */(node === null || node === void 0 ? void 0 : (_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.kind) === 'constructor';
+  return (node === null || node === void 0 ? void 0 : node.type) === 'MethodDefinition' && node.kind === 'constructor' || /** @type {import('@typescript-eslint/types').TSESTree.MethodDefinition} */(node === null || node === void 0 || (_node$parent = node.parent) === null || _node$parent === void 0 ? void 0 : _node$parent.kind) === 'constructor';
 };
 
 /**