eslint-plugin-jsdoc 46.4.5 → 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/rules/checkAccess.d.ts

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

package/dist/rules/checkAccess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAccess.d.ts","sourceRoot":"","sources":["../../src/rules/checkAccess.js"],"names":[],"mappings":""}

package/dist/rules/checkAlignment.d.ts

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

package/dist/rules/checkAlignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkAlignment.d.ts","sourceRoot":"","sources":["../../src/rules/checkAlignment.js"],"names":[],"mappings":""}

package/dist/rules/checkExamples.d.ts

@@ -0,0 +1,4 @@
+declare const _default: eslint.Rule.RuleModule;
+export default _default;
+import eslint from 'eslint';
+//# sourceMappingURL=checkExamples.d.ts.map

package/dist/rules/checkExamples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkExamples.d.ts","sourceRoot":"","sources":["../../src/rules/checkExamples.js"],"names":[],"mappings":";;mBAKO,QAAQ"}

package/dist/rules/checkExamples.js

@@ -5,12 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc.js"));
-var _eslint = require("eslint");
+var _eslint = _interopRequireWildcard(require("eslint"));
 var _semver = _interopRequireDefault(require("semver"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // Todo: When replace `CLIEngine` with `ESLint` when feature set complete per https://github.com/eslint/eslint/issues/14745
 // https://github.com/eslint/eslint/blob/master/docs/user-guide/migrating-to-7.0.0.md#-the-cliengine-class-has-been-deprecated
 
+const {
+  // @ts-expect-error Older ESLint
+  CLIEngine
+} = _eslint.default;
 const zeroBasedLineIndexAdjust = -1;
 const likelyNestedJSDocIndentSpace = 1;
 const preTagSpaceLength = 1;
@@ -30,7 +36,7 @@ const escapeStringRegexp = str => {
 /**
  * @param {string} str
  * @param {string} ch
- * @returns {import('../iterateJsdoc').Integer}
+ * @returns {import('../iterateJsdoc.js').Integer}
  */
 const countChars = (str, ch) => {
   return (str.match(new RegExp(escapeStringRegexp(ch), 'gu')) || []).length;
@@ -190,8 +196,8 @@ var _default = (0, _iterateJsdoc.default)(({
 
     /**
      * @param {{
-     *   nonJSPrefacingCols: import('../iterateJsdoc').Integer,
-     *   nonJSPrefacingLines: import('../iterateJsdoc').Integer,
+     *   nonJSPrefacingCols: import('../iterateJsdoc.js').Integer,
+     *   nonJSPrefacingLines: import('../iterateJsdoc.js').Integer,
      *   string: string
      * }} cfg
      */
@@ -219,7 +225,7 @@ var _default = (0, _iterateJsdoc.default)(({
       if (matchingFileNameMap.has(fileNameMapKey)) {
         cliFile = matchingFileNameMap.get(fileNameMapKey);
       } else {
-        const cli = new _eslint.CLIEngine(cliConfig);
+        const cli = new CLIEngine(cliConfig);
         let config;
         if (filename || checkEslintrc) {
           config = cli.getConfigForFile(file);
@@ -228,7 +234,7 @@ var _default = (0, _iterateJsdoc.default)(({
         // We need a new instance to ensure that the rules that may only
         //  be available to `file` (if it has its own `.eslintrc`),
         //  will be defined.
-        cliFile = new _eslint.CLIEngine({
+        cliFile = new CLIEngine({
           allowInlineConfig,
           baseConfig: {
             ...baseConfig,