| 1 | {"version":3,"sources":["../src/jsdocUtils.js"],"names":["getFunctionParameterNames","functionNode","getParamName","param","_","has","name","left","type","get","argument","parameter","Error","params","map","getJsdocParameterNamesDeep","jsdoc","targetTagName","jsdocParameterNames","filter","tags","tag","getJsdocParameterNames","includes","modeWarnSettings","getTagNamesForMode","mode","context","jsdocTags","typeScriptTags","closureTags","hasBeenWarned","report","loc","start","column","line","message","markSettingAsWarned","getPreferredTagName","tagPreference","prefValues","values","some","prefVal","replacement","tagNames","preferredTagName","findKey","aliases","isValidTag","definedTags","validTagNames","keys","concat","flatten","additionalTags","allTags","hasTag","targetTagLower","toLowerCase","doc","hasATag","targetTagNames","hasDefinedTypeReturnTag","tagType","trim","tagsWithMandatoryType","tagsWithOptionalType","tagsWithOptionalTypeClosure","namepathDefiningTags","tagsWithOptionalNamepath","tagsWithMandatoryNamepath","tagsWithMandatoryTypeOrNamepath","isNamepathDefiningTag","tagName","tagMightHaveAType","tagMustHaveType","tagMightHaveNamepath","tagMustHaveNamepath","tagMightHaveEitherTypeOrNamepath","tagMustHaveEitherTypeOrNamepath","hasReturnValue","node","expression","body","bodyNode","consequent","alternate","block","handler","finalizer","cases","someCase","parseClosureTemplateTag","description","split","enforcedContexts","defaultContexts","options","contexts","getContextObject","checkJsdoc","reduce","obj","prop","filterTags","tagsWithNamesAndDescriptions","getTagsByType","descName","tagsWithoutNames","tagsWithNames","tagWithName","push","getAncestor","sourceCode","nde","depth","idx","prevToken","getTokenBefore","getIndent","indent","text","match","charAt"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport {jsdocTags, closureTags, typeScriptTags} from './tagNames';\nimport WarnSettings from './WarnSettings';\n\ntype ParserMode = \"jsdoc\"|\"typescript\"|\"closure\";\n\nconst getFunctionParameterNames = (functionNode : Object) : Array<string> => {\n const getParamName = (param) => {\n if (_.has(param, 'name')) {\n return param.name;\n }\n\n if (_.has(param, 'left.name')) {\n return param.left.name;\n }\n\n if (param.type === 'ObjectPattern' || _.get(param, 'left.type') === 'ObjectPattern') {\n return '<ObjectPattern>';\n }\n\n if (param.type === 'ArrayPattern' || _.get(param, 'left.type') === 'ArrayPattern') {\n return '<ArrayPattern>';\n }\n\n if (param.type === 'RestElement') {\n return param.argument.name;\n }\n\n if (param.type === 'TSParameterProperty') {\n return getParamName(param.parameter);\n }\n\n throw new Error('Unsupported function signature format.');\n };\n\n return functionNode.params.map(getParamName);\n};\n\n/**\n * Gets all parameter names, including those that refer to a path, e.g. \"@param foo; @param foo.bar\".\n */\nconst getJsdocParameterNamesDeep = (jsdoc : Object, targetTagName : string) : Array<string> => {\n let jsdocParameterNames;\n\n jsdocParameterNames = _.filter(jsdoc.tags, {\n tag: targetTagName,\n });\n\n jsdocParameterNames = _.map(jsdocParameterNames, 'name');\n\n return jsdocParameterNames;\n};\n\nconst getJsdocParameterNames = (jsdoc : Object, targetTagName : string) : Array<string> => {\n let jsdocParameterNames;\n\n jsdocParameterNames = getJsdocParameterNamesDeep(jsdoc, targetTagName);\n\n jsdocParameterNames = jsdocParameterNames.filter((name) => {\n return !name.includes('.');\n });\n\n return jsdocParameterNames;\n};\n\nconst modeWarnSettings = WarnSettings();\n\nconst getTagNamesForMode = (mode, context) => {\n switch (mode) {\n case 'jsdoc':\n return jsdocTags;\n case 'typescript':\n return typeScriptTags;\n case 'closure':\n return closureTags;\n default:\n if (!modeWarnSettings.hasBeenWarned(context, 'mode')) {\n context.report({\n loc: {\n start: {\n column: 1,\n line: 1,\n },\n },\n message: `Unrecognized value \\`${mode}\\` for \\`settings.jsdoc.mode\\`.`,\n });\n modeWarnSettings.markSettingAsWarned(context, 'mode');\n }\n\n // We'll avoid breaking too many other rules\n return jsdocTags;\n }\n};\n\nconst getPreferredTagName = (\n context,\n mode : ParserMode,\n name : string,\n tagPreference : Object = {},\n) : string => {\n const prefValues = _.values(tagPreference);\n if (prefValues.includes(name) || prefValues.some((prefVal) => {\n return prefVal && typeof prefVal === 'object' && prefVal.replacement === name;\n })) {\n return name;\n }\n\n if (_.has(tagPreference, name)) {\n return tagPreference[name];\n }\n\n const tagNames = getTagNamesForMode(mode, context);\n\n const preferredTagName = _.findKey(tagNames, (aliases) => {\n return aliases.includes(name);\n });\n if (preferredTagName) {\n return preferredTagName;\n }\n\n return name;\n};\n\nconst isValidTag = (\n context,\n mode : ParserMode,\n name : string,\n definedTags : Array,\n) : boolean => {\n const tagNames = getTagNamesForMode(mode, context);\n const validTagNames = _.keys(tagNames).concat(_.flatten(_.values(tagNames)));\n const additionalTags = definedTags;\n const allTags = validTagNames.concat(additionalTags);\n\n return allTags.includes(name);\n};\n\nconst hasTag = (jsdoc : Object, targetTagName : string) : boolean => {\n const targetTagLower = targetTagName.toLowerCase();\n\n return _.some(jsdoc.tags, (doc : Object) => {\n return doc.tag.toLowerCase() === targetTagLower;\n });\n};\n\nconst hasATag = (jsdoc : Object, targetTagNames : Array) : boolean => {\n return targetTagNames.some((targetTagName) => {\n return hasTag(jsdoc, targetTagName);\n });\n};\n\n/**\n * Checks if the JSDoc comment declares a return value.\n *\n * @param {JsDocTag} tag\n * the tag which should be checked.\n * @returns {boolean}\n * true in case a return value is declared; otherwise false.\n */\nconst hasDefinedTypeReturnTag = (tag) => {\n // The function should not continue in the event @returns is not defined...\n if (typeof tag === 'undefined' || tag === null) {\n return false;\n }\n\n // .. same applies if it declares `@returns {undefined}` or `@returns {void}`\n const tagType = tag.type.trim();\n if (tagType === 'undefined' || tagType === 'void') {\n return false;\n }\n\n // In any other case, something must be returned, and\n // a return statement is expected\n return true;\n};\n\n// Todo: These type and namepath tag listings currently look\n// at tags with `{...}` as being a type, but jsdoc may\n// allow some namepaths only within brackets as well\n\nconst tagsWithMandatoryType = [\n // These both show curly brackets in the doc signature and examples\n // \"typeExpression\"\n 'implements',\n\n // \"typeName\"\n 'type',\n];\n\n// All of these have a signature with \"type\" except for\n// `augments`/`extends` (\"namepath\")\n// `param`/`arg`/`argument` (no signature)\n// `property`/`prop` (no signature)\n// `modifies` (undocumented)\nconst tagsWithOptionalType = [\n // These have the example showing curly brackets but not in their doc signature, e.g.: https://jsdoc.app/tags-enum.html\n 'enum',\n 'member', 'var',\n\n 'typedef',\n\n // These do not show curly brackets in either the signature or examples\n 'augments', 'extends',\n\n 'class', 'constructor',\n 'constant', 'const',\n\n // These show the signature with curly brackets but not in the example\n 'module',\n 'namespace',\n\n // These have no formal signature in the docs but show curly brackets\n // in the examples\n 'param', 'arg', 'argument',\n 'property', 'prop',\n\n // These show curly brackets in the signature and in the examples\n 'returns', 'return',\n 'throws', 'exception',\n 'yields', 'yield',\n\n // Has no documentation, but test example has curly brackets, and\n // \"name\" would be suggested rather than \"namepath\" based on example; not\n // sure if name is required\n 'modifies',\n];\n\nconst tagsWithOptionalTypeClosure = [\n ...tagsWithOptionalType,\n\n // Shows the signature with curly brackets but not in the example\n // \"typeExpression\"\n 'package',\n 'private',\n 'protected',\n\n // These do not show a signature nor show curly brackets in the example\n 'public',\n 'static',\n];\n\n// None of these show as having curly brackets for their name/namepath\nconst namepathDefiningTags = [\n // These appear to require a \"name\" in their signature, albeit these\n // are somewhat different from other \"name\"'s (including as described\n // at https://jsdoc.app/about-namepaths.html )\n 'external', 'host',\n 'event',\n\n // These allow for \"name\"'s in their signature, but indicate as optional\n 'class', 'constructor',\n 'constant', 'const',\n 'function', 'func', 'method',\n 'interface',\n 'member', 'var',\n 'mixin',\n 'namespace',\n\n // Todo: Should add `module` here (with optional \"name\" and no curly brackets);\n // this block impacts `no-undefined-types` and `valid-types` (search for \"isNamepathDefiningTag|tagMightHaveNamepath|tagMightHaveEitherTypeOrNamepath\")\n\n // These seem to all require a \"namepath\" in their signatures (with no counter-examples)\n 'name',\n 'typedef',\n 'callback',\n];\n\n// The following do not seem to allow curly brackets in their doc\n// signature or examples (besides `modifies`)\nconst tagsWithOptionalNamepath = [\n ...namepathDefiningTags,\n\n // `borrows` has a different format, however, so needs special parsing;\n // seems to require both, and as \"namepath\"'s\n 'borrows',\n\n // Signature seems to require a \"name\" (of an event) and no counter-examples\n 'emits', 'fires',\n 'listens',\n\n // Signature seems to require a \"namepath\" (and no counter-examples)\n 'alias',\n 'augments', 'extends',\n 'lends',\n 'this',\n\n // Signature seems to require a \"namepath\" (and no counter-examples),\n // though it allows an incomplete namepath ending with connecting symbol\n 'memberof', 'memberof!',\n\n // Signature seems to require a \"OtherObjectPath\" with no counter-examples\n 'mixes',\n\n // Signature allows for \"namepath\" or text\n 'see',\n];\n\n// Todo: `@link` seems to require a namepath OR URL and might be checked as such.\n\n// The doc signature of `event` seems to require a \"name\"\nconst tagsWithMandatoryNamepath = [\n // \"name\" (and a special syntax for the `external` name)\n 'external', 'host',\n\n // \"namepath\"\n 'callback',\n 'name',\n 'typedef',\n];\n\nconst tagsWithMandatoryTypeOrNamepath = [\n // \"namepath\"\n 'alias',\n 'augments', 'extends',\n 'borrows',\n 'lends',\n 'memberof', 'memberof!',\n 'name',\n 'this',\n 'typedef',\n\n // \"name\"\n 'external', 'host',\n\n // \"OtherObjectPath\"\n 'mixes',\n];\n\nconst isNamepathDefiningTag = (tagName) => {\n return namepathDefiningTags.includes(tagName);\n};\n\nconst tagMightHaveAType = (mode, tag) => {\n return tagsWithMandatoryType.includes(tag) || (mode === 'closure' ?\n tagsWithOptionalTypeClosure.includes(tag) :\n tagsWithOptionalType.includes(tag));\n};\n\nconst tagMustHaveType = (tag) => {\n return tagsWithMandatoryType.includes(tag);\n};\n\nconst tagMightHaveNamepath = (tag) => {\n return tagsWithOptionalNamepath.includes(tag);\n};\n\nconst tagMustHaveNamepath = (tag) => {\n return tagsWithMandatoryNamepath.includes(tag);\n};\n\nconst tagMightHaveEitherTypeOrNamepath = (mode, tag) => {\n return tagMightHaveAType(mode, tag) || tagMightHaveNamepath(tag);\n};\n\nconst tagMustHaveEitherTypeOrNamepath = (tag) => {\n return tagsWithMandatoryTypeOrNamepath.includes(tag);\n};\n\n/**\n * Checks if a node has a return statement. Void return does not count.\n *\n * @param {object} node\n * @returns {boolean}\n */\n// eslint-disable-next-line complexity\nconst hasReturnValue = (node) => {\n if (!node) {\n return false;\n }\n switch (node.type) {\n case 'FunctionExpression':\n case 'FunctionDeclaration':\n case 'ArrowFunctionExpression': {\n return node.expression || hasReturnValue(node.body);\n }\n case 'BlockStatement': {\n return node.body.some((bodyNode) => {\n return bodyNode.type !== 'FunctionDeclaration' && hasReturnValue(bodyNode);\n });\n }\n case 'WhileStatement':\n case 'DoWhileStatement':\n case 'ForStatement':\n case 'ForInStatement':\n case 'ForOfStatement':\n case 'WithStatement': {\n return hasReturnValue(node.body);\n }\n case 'IfStatement': {\n return hasReturnValue(node.consequent) || hasReturnValue(node.alternate);\n }\n case 'TryStatement': {\n return hasReturnValue(node.block) ||\n hasReturnValue(node.handler && node.handler.body) ||\n hasReturnValue(node.finalizer);\n }\n case 'SwitchStatement': {\n return node.cases.some(\n (someCase) => {\n return someCase.consequent.some(hasReturnValue);\n },\n );\n }\n case 'ReturnStatement': {\n // void return does not count.\n if (node.argument === null) {\n return false;\n }\n\n return true;\n }\n default: {\n return false;\n }\n }\n};\n\n/** @param {string} tag */\n/*\nconst isInlineTag = (tag) => {\n return /^(@link|@linkcode|@linkplain|@tutorial) /u.test(tag);\n};\n*/\n\n/**\n * Parses GCC Generic/Template types\n *\n * @see {https://github.com/google/closure-compiler/wiki/Generic-Types}\n * @param {JsDocTag} tag\n * @returns {Array<string>}\n */\nconst parseClosureTemplateTag = (tag) => {\n return (tag.name + ' ' + tag.description)\n .split(',')\n .map((type) => {\n return type.trim();\n });\n};\n\n/**\n * Checks user option for `contexts` array, defaulting to\n * contexts designated by the rule. Returns an array of\n * ESTree AST types, indicating allowable contexts.\n *\n * @param {*} context\n * @param {true|string[]} defaultContexts\n * @returns {string[]}\n */\nconst enforcedContexts = (context, defaultContexts) => {\n const {\n /* istanbul ignore next */\n contexts = defaultContexts === true ? [\n 'ArrowFunctionExpression',\n 'FunctionDeclaration',\n 'FunctionExpression',\n ] : defaultContexts,\n } = context.options[0] || {};\n\n return contexts;\n};\n\n/**\n * @param {string[]} contexts\n * @param {Function} checkJsdoc\n */\nconst getContextObject = (contexts, checkJsdoc) => {\n return contexts.reduce((obj, prop) => {\n obj[prop] = checkJsdoc;\n\n return obj;\n }, {});\n};\n\nconst filterTags = (tags = [], filter) => {\n return tags.filter(filter);\n};\n\nconst tagsWithNamesAndDescriptions = [\n 'param', 'arg', 'argument', 'property', 'prop',\n\n // These two are parsed by our custom parser as though having a `name`\n 'returns', 'return',\n];\n\nconst getTagsByType = (context, mode, tags, tagPreference) => {\n const descName = getPreferredTagName(context, mode, 'description', tagPreference);\n const tagsWithoutNames = [];\n const tagsWithNames = filterTags(tags, (tag) => {\n const {tag: tagName} = tag;\n const tagWithName = tagsWithNamesAndDescriptions.includes(tagName);\n if (!tagWithName && tagName !== descName) {\n tagsWithoutNames.push(tag);\n }\n\n return tagWithName;\n });\n\n return {\n tagsWithNames,\n tagsWithoutNames,\n };\n};\n\nconst getAncestor = (sourceCode, nde, depth, idx = 0) => {\n if (idx === depth) {\n return nde;\n }\n const prevToken = sourceCode.getTokenBefore(nde);\n if (prevToken) {\n return getAncestor(sourceCode, prevToken, depth, idx + 1);\n }\n\n return null;\n};\n\nconst getIndent = (sourceCode) => {\n let indent = sourceCode.text.match(/^\\n*([ \\t]+)/u);\n /* istanbul ignore next */\n indent = indent ? indent[1] + indent[1].charAt() : ' ';\n\n return indent;\n};\n\nexport default {\n enforcedContexts,\n filterTags,\n getAncestor,\n getContextObject,\n getFunctionParameterNames,\n getIndent,\n getJsdocParameterNames,\n getJsdocParameterNamesDeep,\n getPreferredTagName,\n getTagsByType,\n hasATag,\n hasDefinedTypeReturnTag,\n hasReturnValue,\n hasTag,\n isNamepathDefiningTag,\n isValidTag,\n parseClosureTemplateTag,\n tagMightHaveAType,\n tagMightHaveEitherTypeOrNamepath,\n tagMightHaveNamepath,\n tagMustHaveEitherTypeOrNamepath,\n tagMustHaveNamepath,\n tagMustHaveType,\n};\n"],"file":"jsdocUtils.js"} |