eslint-plugin-jsdoc 37.9.1 → 37.9.2

package/dist/jsdocUtils.js

@@ -14,6 +14,10 @@ var _tagNames = require("./tagNames");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /* eslint-disable jsdoc/no-undefined-types */
+
+/**
+ * @typedef {"jsdoc"|"typescript"|"closure"} ParserMode
+ */
 let tagStructure;
 
 const setTagStructure = mode => {
@@ -86,6 +90,11 @@ const flattenRoots = (params, root = '') => {
     rests
   };
 };
+/**
+ * @param {object} propSignature
+ * @returns {undefined|Array|string}
+ */
+
 
 const getPropertiesFromPropertySignature = propSignature => {
   if (propSignature.type === 'TSIndexSignature' || propSignature.type === 'TSConstructSignatureDeclaration' || propSignature.type === 'TSCallSignatureDeclaration') {
@@ -100,6 +109,12 @@ const getPropertiesFromPropertySignature = propSignature => {
 
   return propSignature.key.name;
 };
+/**
+ * @param {object} functionNode
+ * @param {boolean} checkDefaultObjects
+ * @returns {Array}
+ */
+
 
 const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
   // eslint-disable-next-line complexity
@@ -243,6 +258,11 @@ const getFunctionParameterNames = (functionNode, checkDefaultObjects) => {
     return getParamName(param);
   });
 };
+/**
+ * @param {Node} functionNode
+ * @returns {Integer}
+ */
+
 
 const hasParams = functionNode => {
   // Should also check `functionNode.value.params` if supporting `MethodDefinition`
@@ -251,6 +271,10 @@ const hasParams = functionNode => {
 /**
  * Gets all names of the target type, including those that refer to a path, e.g.
  * "@param foo; @param foo.bar".
+ *
+ * @param {object} jsdoc
+ * @param {string} targetTagName
+ * @returns {Array<object>}
  */
 
 
@@ -277,6 +301,10 @@ const getJsdocTagsDeep = (jsdoc, targetTagName) => {
 };
 
 const modeWarnSettings = (0, _WarnSettings.default)();
+/**
+ * @param {string} mode
+ * @param context
+ */
 
 const getTagNamesForMode = (mode, context) => {
   switch (mode) {
@@ -308,6 +336,14 @@ const getTagNamesForMode = (mode, context) => {
       return _tagNames.jsdocTags;
   }
 };
+/**
+ * @param context
+ * @param {ParserMode} mode
+ * @param {string} name
+ * @param {object} tagPreference
+ * @returns {string|object}
+ */
+
 
 const getPreferredTagName = (context, mode, name, tagPreference = {}) => {
   var _Object$entries$find;
@@ -344,6 +380,14 @@ const getPreferredTagName = (context, mode, name, tagPreference = {}) => {
 
   return name;
 };
+/**
+ * @param context
+ * @param {ParserMode} mode
+ * @param {string} name
+ * @param {Array} definedTags
+ * @returns {boolean}
+ */
+
 
 const isValidTag = (context, mode, name, definedTags) => {
   const tagNames = getTagNamesForMode(mode, context);
@@ -352,6 +396,12 @@ const isValidTag = (context, mode, name, definedTags) => {
   const allTags = validTagNames.concat(additionalTags);
   return allTags.includes(name);
 };
+/**
+ * @param {object} jsdoc
+ * @param {string} targetTagName
+ * @returns {boolean}
+ */
+
 
 const hasTag = (jsdoc, targetTagName) => {
   const targetTagLower = targetTagName.toLowerCase();
@@ -359,6 +409,12 @@ const hasTag = (jsdoc, targetTagName) => {
     return doc.tag.toLowerCase() === targetTagLower;
   });
 };
+/**
+ * @param {object} jsdoc
+ * @param {Array} targetTagNames
+ * @returns {boolean}
+ */
+
 
 const hasATag = (jsdoc, targetTagNames) => {
   return targetTagNames.some(targetTagName => {
@@ -391,6 +447,12 @@ const hasDefinedTypeTag = tag => {
 
   return true;
 };
+/**
+ * @param map
+ * @param tag
+ * @returns {Map}
+ */
+
 
 const ensureMap = (map, tag) => {
   if (!map.has(tag)) {
@@ -399,6 +461,11 @@ const ensureMap = (map, tag) => {
 
   return map.get(tag);
 };
+/**
+ * @param structuredTags
+ * @param tagMap
+ */
+
 
 const overrideTagStructure = (structuredTags, tagMap = tagStructure) => {
   for (const [tag, {
@@ -436,6 +503,12 @@ const overrideTagStructure = (structuredTags, tagMap = tagStructure) => {
     tagStruct.set('typeOrNameRequired', typeOrNameRequired);
   }
 };
+/**
+ * @param mode
+ * @param structuredTags
+ * @returns {Map}
+ */
+
 
 const getTagStructureForMode = (mode, structuredTags) => {
   const tagStruct = (0, _getDefaultTagStructureForMode.default)(mode);
@@ -447,16 +520,34 @@ const getTagStructureForMode = (mode, structuredTags) => {
 
   return tagStruct;
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const isNamepathDefiningTag = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('nameContents') === 'namepath-defining';
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMustHaveTypePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('typeRequired');
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMightHaveTypePosition = (tag, tagMap = tagStructure) => {
   if (tagMustHaveTypePosition(tag, tagMap)) {
@@ -469,31 +560,66 @@ const tagMightHaveTypePosition = (tag, tagMap = tagStructure) => {
 };
 
 const namepathTypes = new Set(['namepath-defining', 'namepath-referencing']);
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
 
 const tagMightHaveNamePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   const ret = tagStruct.get('nameContents');
   return ret === undefined ? true : Boolean(ret);
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMightHaveNamepath = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return namepathTypes.has(tagStruct.get('nameContents'));
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMustHaveNamePosition = (tag, tagMap = tagStructure) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('nameRequired');
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMightHaveEitherTypeOrNamePosition = (tag, tagMap) => {
   return tagMightHaveTypePosition(tag, tagMap) || tagMightHaveNamepath(tag, tagMap);
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMustHaveEitherTypeOrNamePosition = (tag, tagMap) => {
   const tagStruct = ensureMap(tagMap, tag);
   return tagStruct.get('typeOrNameRequired');
 };
+/**
+ * @param tag
+ * @param {Map} tagMap
+ * @returns {boolean}
+ */
+
 
 const tagMissingRequiredTypeOrNamepath = (tag, tagMap = tagStructure) => {
   const mustHaveTypePosition = tagMustHaveTypePosition(tag.tag, tagMap);
@@ -1293,16 +1419,33 @@ const exemptSpeciaMethods = (jsdoc, node, context, schema) => {
 const dropPathSegmentQuotes = str => {
   return str.replace(/\.(['"])(.*)\1/gu, '.$2');
 };
+/**
+ * @param {string} name
+ * @returns {(otherPathName: string) => void}
+ */
+
 
 const comparePaths = name => {
   return otherPathName => {
     return otherPathName === name || dropPathSegmentQuotes(otherPathName) === dropPathSegmentQuotes(name);
   };
 };
+/**
+ * @param {string} name
+ * @param {string} otherPathName
+ * @returns {boolean}
+ */
+
 
 const pathDoesNotBeginWith = (name, otherPathName) => {
   return !name.startsWith(otherPathName) && !dropPathSegmentQuotes(name).startsWith(dropPathSegmentQuotes(otherPathName));
 };
+/**
+ * @param {string} regexString
+ * @param {string} requiredFlags
+ * @returns {RegExp}
+ */
+
 
 const getRegexFromString = (regexString, requiredFlags) => {
   const match = regexString.match(/^\/(.*)\/([gimyus]*)$/us);