eslint-plugin-jsdoc 53.0.1 → 54.0.0

package/dist/tagNames.js

@@ -1,144 +0,0 @@
-//#region src/tagNames.js
-/**
-* @typedef {{
-*   [key: string]: string[]
-* }} AliasedTags
-*/
-/**
-* @type {AliasedTags}
-*/
-const jsdocTagsUndocumented = { modifies: [] };
-/**
-* @type {AliasedTags}
-*/
-const jsdocTags = {
-	...jsdocTagsUndocumented,
-	abstract: ["virtual"],
-	access: [],
-	alias: [],
-	async: [],
-	augments: ["extends"],
-	author: [],
-	borrows: [],
-	callback: [],
-	class: ["constructor"],
-	classdesc: [],
-	constant: ["const"],
-	constructs: [],
-	copyright: [],
-	default: ["defaultvalue"],
-	deprecated: [],
-	description: ["desc"],
-	enum: [],
-	event: [],
-	example: [],
-	exports: [],
-	external: ["host"],
-	file: ["fileoverview", "overview"],
-	fires: ["emits"],
-	function: ["func", "method"],
-	generator: [],
-	global: [],
-	hideconstructor: [],
-	ignore: [],
-	implements: [],
-	inheritdoc: [],
-	inheritDoc: [],
-	inner: [],
-	instance: [],
-	interface: [],
-	kind: [],
-	lends: [],
-	license: [],
-	listens: [],
-	member: ["var"],
-	memberof: [],
-	"memberof!": [],
-	mixes: [],
-	mixin: [],
-	module: [],
-	name: [],
-	namespace: [],
-	override: [],
-	package: [],
-	param: ["arg", "argument"],
-	private: [],
-	property: ["prop"],
-	protected: [],
-	public: [],
-	readonly: [],
-	requires: [],
-	returns: ["return"],
-	see: [],
-	since: [],
-	static: [],
-	summary: [],
-	this: [],
-	throws: ["exception"],
-	todo: [],
-	tutorial: [],
-	type: [],
-	typedef: [],
-	variation: [],
-	version: [],
-	yields: ["yield"]
-};
-/**
-* @type {AliasedTags}
-*/
-const typeScriptTags = {
-	...jsdocTags,
-	import: [],
-	internal: [],
-	overload: [],
-	satisfies: [],
-	template: []
-};
-/**
-* @type {AliasedTags}
-*/
-const undocumentedClosureTags = {
-	closurePrimitive: [],
-	customElement: [],
-	expose: [],
-	hidden: [],
-	idGenerator: [],
-	meaning: [],
-	mixinClass: [],
-	mixinFunction: [],
-	ngInject: [],
-	owner: [],
-	typeSummary: [],
-	wizaction: []
-};
-const { inheritdoc, internal, overload, returns, satisfies,...typeScriptTagsInClosure } = typeScriptTags;
-/**
-* @type {AliasedTags}
-*/
-const closureTags = {
-	...typeScriptTagsInClosure,
-	...undocumentedClosureTags,
-	define: [],
-	dict: [],
-	export: [],
-	externs: [],
-	final: [],
-	implicitCast: [],
-	noalias: [],
-	nocollapse: [],
-	nocompile: [],
-	noinline: [],
-	nosideeffects: [],
-	polymer: [],
-	polymerBehavior: [],
-	preserve: [],
-	record: [],
-	return: ["returns"],
-	struct: [],
-	suppress: [],
-	unrestricted: []
-};
-
-//#endregion
-export { closureTags, jsdocTags, typeScriptTags };
-//# sourceMappingURL=tagNames.js.map

package/dist/tagNames.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tagNames.js","names":[],"sources":["../src/tagNames.js"],"sourcesContent":["/**\n * @typedef {{\n *   [key: string]: string[]\n * }} AliasedTags\n */\n\n/**\n * @type {AliasedTags}\n */\nconst jsdocTagsUndocumented = {\n  // Undocumented but present; see\n  // https://github.com/jsdoc/jsdoc/issues/1283#issuecomment-516816802\n  // https://github.com/jsdoc/jsdoc/blob/master/packages/jsdoc/lib/jsdoc/tag/dictionary/definitions.js#L594\n  modifies: [],\n};\n\n/**\n * @type {AliasedTags}\n */\nconst jsdocTags = {\n  ...jsdocTagsUndocumented,\n  abstract: [\n    'virtual',\n  ],\n  access: [],\n  alias: [],\n  async: [],\n  augments: [\n    'extends',\n  ],\n  author: [],\n  borrows: [],\n  callback: [],\n  class: [\n    'constructor',\n  ],\n  classdesc: [],\n  constant: [\n    'const',\n  ],\n  constructs: [],\n  copyright: [],\n  default: [\n    'defaultvalue',\n  ],\n  deprecated: [],\n  description: [\n    'desc',\n  ],\n  enum: [],\n  event: [],\n  example: [],\n  exports: [],\n  external: [\n    'host',\n  ],\n  file: [\n    'fileoverview',\n    'overview',\n  ],\n  fires: [\n    'emits',\n  ],\n  function: [\n    'func',\n    'method',\n  ],\n  generator: [],\n  global: [],\n  hideconstructor: [],\n  ignore: [],\n  implements: [],\n  inheritdoc: [],\n\n  // Allowing casing distinct from jsdoc `definitions.js` (required in Closure)\n  inheritDoc: [],\n\n  inner: [],\n  instance: [],\n  interface: [],\n  kind: [],\n  lends: [],\n  license: [],\n  listens: [],\n  member: [\n    'var',\n  ],\n  memberof: [],\n  'memberof!': [],\n  mixes: [],\n  mixin: [],\n\n  module: [],\n  name: [],\n  namespace: [],\n  override: [],\n  package: [],\n  param: [\n    'arg',\n    'argument',\n  ],\n  private: [],\n  property: [\n    'prop',\n  ],\n  protected: [],\n  public: [],\n  readonly: [],\n  requires: [],\n  returns: [\n    'return',\n  ],\n  see: [],\n  since: [],\n  static: [],\n  summary: [],\n\n  this: [],\n  throws: [\n    'exception',\n  ],\n  todo: [],\n  tutorial: [],\n  type: [],\n  typedef: [],\n  variation: [],\n  version: [],\n  yields: [\n    'yield',\n  ],\n};\n\n/**\n * @type {AliasedTags}\n */\nconst typeScriptTags = {\n  ...jsdocTags,\n\n  // https://github.com/microsoft/TypeScript/issues/22160\n  // https://devblogs.microsoft.com/typescript/announcing-typescript-5-5/#the-jsdoc-import-tag\n  import: [],\n\n  // https://www.typescriptlang.org/tsconfig/#stripInternal\n  internal: [],\n\n  // https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#overload-support-in-jsdoc\n  overload: [],\n\n  // https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#satisfies-support-in-jsdoc\n  satisfies: [],\n\n  // `@template` is also in TypeScript per:\n  //      https://www.typescriptlang.org/docs/handbook/type-checking-javascript-files.html#supported-jsdoc\n  template: [],\n};\n\n/**\n * @type {AliasedTags}\n */\nconst undocumentedClosureTags = {\n  // These are in Closure source but not in jsdoc source nor in the Closure\n  //  docs: https://github.com/google/closure-compiler/blob/master/src/com/google/javascript/jscomp/parsing/Annotation.java\n  closurePrimitive: [],\n  customElement: [],\n  expose: [],\n  hidden: [],\n  idGenerator: [],\n  meaning: [],\n  mixinClass: [],\n  mixinFunction: [],\n  ngInject: [],\n  owner: [],\n  typeSummary: [],\n  wizaction: [],\n};\n\nconst {\n  /* eslint-disable no-unused-vars */\n  inheritdoc,\n  internal,\n  overload,\n  // Will be inverted to prefer `return`\n  returns,\n\n  satisfies,\n  /* eslint-enable no-unused-vars */\n  ...typeScriptTagsInClosure\n} = typeScriptTags;\n\n/**\n * @type {AliasedTags}\n */\nconst closureTags = {\n  ...typeScriptTagsInClosure,\n  ...undocumentedClosureTags,\n\n  // From https://github.com/google/closure-compiler/wiki/Annotating-JavaScript-for-the-Closure-Compiler\n  // These are all recognized in https://github.com/jsdoc/jsdoc/blob/master/packages/jsdoc/lib/jsdoc/tag/dictionary/definitions.js\n  //   except for the experimental `noinline` and the casing differences noted below\n\n  // Defined as a synonym of `const` in jsdoc `definitions.js`\n  define: [],\n\n  dict: [],\n  export: [],\n  externs: [],\n  final: [],\n\n  // With casing distinct from jsdoc `definitions.js`\n  implicitCast: [],\n\n  noalias: [],\n  nocollapse: [],\n  nocompile: [],\n  noinline: [],\n  nosideeffects: [],\n  polymer: [],\n  polymerBehavior: [],\n  preserve: [],\n\n  // Defined as a synonym of `interface` in jsdoc `definitions.js`\n  record: [],\n\n  return: [\n    'returns',\n  ],\n\n  struct: [],\n  suppress: [],\n\n  unrestricted: [],\n};\n\nexport {\n  closureTags,\n  jsdocTags,\n  typeScriptTags,\n};\n"],"mappings":";;;;;;;;;AASA,MAAM,wBAAwB,EAI5B,UAAU,CAAE,EACb;;;;AAKD,MAAM,YAAY;CAChB,GAAG;CACH,UAAU,CACR,SACD;CACD,QAAQ,CAAE;CACV,OAAO,CAAE;CACT,OAAO,CAAE;CACT,UAAU,CACR,SACD;CACD,QAAQ,CAAE;CACV,SAAS,CAAE;CACX,UAAU,CAAE;CACZ,OAAO,CACL,aACD;CACD,WAAW,CAAE;CACb,UAAU,CACR,OACD;CACD,YAAY,CAAE;CACd,WAAW,CAAE;CACb,SAAS,CACP,cACD;CACD,YAAY,CAAE;CACd,aAAa,CACX,MACD;CACD,MAAM,CAAE;CACR,OAAO,CAAE;CACT,SAAS,CAAE;CACX,SAAS,CAAE;CACX,UAAU,CACR,MACD;CACD,MAAM,CACJ,gBACA,UACD;CACD,OAAO,CACL,OACD;CACD,UAAU,CACR,QACA,QACD;CACD,WAAW,CAAE;CACb,QAAQ,CAAE;CACV,iBAAiB,CAAE;CACnB,QAAQ,CAAE;CACV,YAAY,CAAE;CACd,YAAY,CAAE;CAGd,YAAY,CAAE;CAEd,OAAO,CAAE;CACT,UAAU,CAAE;CACZ,WAAW,CAAE;CACb,MAAM,CAAE;CACR,OAAO,CAAE;CACT,SAAS,CAAE;CACX,SAAS,CAAE;CACX,QAAQ,CACN,KACD;CACD,UAAU,CAAE;CACZ,aAAa,CAAE;CACf,OAAO,CAAE;CACT,OAAO,CAAE;CAET,QAAQ,CAAE;CACV,MAAM,CAAE;CACR,WAAW,CAAE;CACb,UAAU,CAAE;CACZ,SAAS,CAAE;CACX,OAAO,CACL,OACA,UACD;CACD,SAAS,CAAE;CACX,UAAU,CACR,MACD;CACD,WAAW,CAAE;CACb,QAAQ,CAAE;CACV,UAAU,CAAE;CACZ,UAAU,CAAE;CACZ,SAAS,CACP,QACD;CACD,KAAK,CAAE;CACP,OAAO,CAAE;CACT,QAAQ,CAAE;CACV,SAAS,CAAE;CAEX,MAAM,CAAE;CACR,QAAQ,CACN,WACD;CACD,MAAM,CAAE;CACR,UAAU,CAAE;CACZ,MAAM,CAAE;CACR,SAAS,CAAE;CACX,WAAW,CAAE;CACb,SAAS,CAAE;CACX,QAAQ,CACN,OACD;AACF;;;;AAKD,MAAM,iBAAiB;CACrB,GAAG;CAIH,QAAQ,CAAE;CAGV,UAAU,CAAE;CAGZ,UAAU,CAAE;CAGZ,WAAW,CAAE;CAIb,UAAU,CAAE;AACb;;;;AAKD,MAAM,0BAA0B;CAG9B,kBAAkB,CAAE;CACpB,eAAe,CAAE;CACjB,QAAQ,CAAE;CACV,QAAQ,CAAE;CACV,aAAa,CAAE;CACf,SAAS,CAAE;CACX,YAAY,CAAE;CACd,eAAe,CAAE;CACjB,UAAU,CAAE;CACZ,OAAO,CAAE;CACT,aAAa,CAAE;CACf,WAAW,CAAE;AACd;AAED,MAAM,EAEJ,YACA,UACA,UAEA,SAEA,UAEA,GAAG,yBACJ,GAAG;;;;AAKJ,MAAM,cAAc;CAClB,GAAG;CACH,GAAG;CAOH,QAAQ,CAAE;CAEV,MAAM,CAAE;CACR,QAAQ,CAAE;CACV,SAAS,CAAE;CACX,OAAO,CAAE;CAGT,cAAc,CAAE;CAEhB,SAAS,CAAE;CACX,YAAY,CAAE;CACd,WAAW,CAAE;CACb,UAAU,CAAE;CACZ,eAAe,CAAE;CACjB,SAAS,CAAE;CACX,iBAAiB,CAAE;CACnB,UAAU,CAAE;CAGZ,QAAQ,CAAE;CAEV,QAAQ,CACN,SACD;CAED,QAAQ,CAAE;CACV,UAAU,CAAE;CAEZ,cAAc,CAAE;AACjB"}

package/dist/utils/hasReturnValue.js

@@ -1,265 +0,0 @@
-//#region src/utils/hasReturnValue.js
-/**
-* @typedef {import('estree').Node|
-*   import('@typescript-eslint/types').TSESTree.Node} ESTreeOrTypeScriptNode
-*/
-/**
-* Checks if a node is a promise but has no resolve value or an empty value.
-* An `undefined` resolve does not count.
-* @param {ESTreeOrTypeScriptNode|undefined|null} node
-* @returns {boolean|undefined|null}
-*/
-const isNewPromiseExpression = (node) => {
-	return node && node.type === "NewExpression" && node.callee.type === "Identifier" && node.callee.name === "Promise";
-};
-/**
-* @param {ESTreeOrTypeScriptNode|null|undefined} node
-* @returns {boolean}
-*/
-const isVoidPromise = (node) => {
-	return node?.typeArguments?.params?.[0]?.type === "TSVoidKeyword" || node?.typeParameters?.params?.[0]?.type === "TSVoidKeyword";
-};
-const undefinedKeywords = new Set([
-	"TSNeverKeyword",
-	"TSUndefinedKeyword",
-	"TSVoidKeyword"
-]);
-/**
-* Checks if a node has a return statement. Void return does not count.
-* @param {ESTreeOrTypeScriptNode|undefined|null} node
-* @param {boolean} [throwOnNullReturn]
-* @param {PromiseFilter} [promFilter]
-* @returns {boolean|undefined}
-*/
-const hasReturnValue = (node, throwOnNullReturn, promFilter) => {
-	if (!node) return false;
-	switch (node.type) {
-		case "ArrowFunctionExpression":
-		case "FunctionDeclaration":
-		case "FunctionExpression": return "expression" in node && node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) || hasReturnValue(node.body, throwOnNullReturn, promFilter);
-		case "BlockStatement": return node.body.some((bodyNode) => {
-			return bodyNode.type !== "FunctionDeclaration" && hasReturnValue(bodyNode, throwOnNullReturn, promFilter);
-		});
-		case "DoWhileStatement":
-		case "ForInStatement":
-		case "ForOfStatement":
-		case "ForStatement":
-		case "LabeledStatement":
-		case "WhileStatement":
-		case "WithStatement": return hasReturnValue(node.body, throwOnNullReturn, promFilter);
-		case "IfStatement": return hasReturnValue(node.consequent, throwOnNullReturn, promFilter) || hasReturnValue(node.alternate, throwOnNullReturn, promFilter);
-		case "MethodDefinition": return hasReturnValue(node.value, throwOnNullReturn, promFilter);
-		case "ReturnStatement":
-			if (node.argument === null) {
-				if (throwOnNullReturn) throw new Error("Null return");
-				return false;
-			}
-			if (promFilter && isNewPromiseExpression(node.argument)) return promFilter(node.argument);
-			return true;
-		case "SwitchStatement": return node.cases.some((someCase) => {
-			return someCase.consequent.some((nde) => {
-				return hasReturnValue(nde, throwOnNullReturn, promFilter);
-			});
-		});
-		case "TryStatement": return hasReturnValue(node.block, throwOnNullReturn, promFilter) || hasReturnValue(node.handler && node.handler.body, throwOnNullReturn, promFilter) || hasReturnValue(node.finalizer, throwOnNullReturn, promFilter);
-		case "TSDeclareFunction":
-		case "TSFunctionType":
-		case "TSMethodSignature": {
-			const type = node?.returnType?.typeAnnotation?.type;
-			return type && !undefinedKeywords.has(type);
-		}
-		default: return false;
-	}
-};
-/**
-* Checks if a node has a return statement. Void return does not count.
-* @param {ESTreeOrTypeScriptNode|null|undefined} node
-* @param {PromiseFilter} promFilter
-* @returns {undefined|boolean|ESTreeOrTypeScriptNode}
-*/
-const allBrancheshaveReturnValues = (node, promFilter) => {
-	if (!node) return false;
-	switch (node.type) {
-		case "ArrowFunctionExpression":
-		case "FunctionDeclaration":
-		case "FunctionExpression": return "expression" in node && node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) || allBrancheshaveReturnValues(node.body, promFilter) || node.body.body.some((nde) => {
-			return nde.type === "ReturnStatement";
-		});
-		case "BlockStatement": {
-			const lastBodyNode = node.body.slice(-1)[0];
-			return allBrancheshaveReturnValues(lastBodyNode, promFilter);
-		}
-		case "DoWhileStatement":
-		case "WhileStatement": if (node.test.value === true) return hasReturnValue(node.body, false, promFilter);
-		case "ForStatement": if (node.test === null) return hasReturnValue(node.body, false, promFilter);
-		case "ForInStatement":
-		case "ForOfStatement":
-		case "LabeledStatement":
-		case "WithStatement": return allBrancheshaveReturnValues(node.body, promFilter);
-		case "IfStatement": return allBrancheshaveReturnValues(node.consequent, promFilter) && allBrancheshaveReturnValues(node.alternate, promFilter);
-		case "ReturnStatement":
-			if (node.argument === null) return false;
-			if (promFilter && isNewPromiseExpression(node.argument)) return promFilter(node.argument);
-			return true;
-		case "SwitchStatement": return node.cases.every((someCase) => {
-			return !someCase.consequent.some((consNode) => {
-				return consNode.type === "BreakStatement" || consNode.type === "ReturnStatement" && consNode.argument === null;
-			});
-		});
-		case "ThrowStatement": return true;
-		case "TryStatement": return node.finalizer && allBrancheshaveReturnValues(node.finalizer, promFilter) || allBrancheshaveReturnValues(node.block, promFilter) && (!node.handler || allBrancheshaveReturnValues(node.handler && node.handler.body, promFilter)) && (!node.finalizer || (() => {
-			try {
-				hasReturnValue(node.finalizer, true, promFilter);
-			} catch (error) {
-				if (error.message === "Null return") return false;
-				/* c8 ignore next 3 */
-				throw error;
-			}
-			return true;
-		})());
-		case "TSDeclareFunction":
-		case "TSFunctionType":
-		case "TSMethodSignature": {
-			const type = node?.returnType?.typeAnnotation?.type;
-			return type && !undefinedKeywords.has(type);
-		}
-		default: return false;
-	}
-};
-/**
-* @callback PromiseFilter
-* @param {ESTreeOrTypeScriptNode|undefined} node
-* @returns {boolean}
-*/
-/**
-* Avoids further checking child nodes if a nested function shadows the
-* resolver, but otherwise, if name is used (by call or passed in as an
-* argument to another function), will be considered as non-empty.
-*
-* This could check for redeclaration of the resolver, but as such is
-* unlikely, we avoid the performance cost of checking everywhere for
-* (re)declarations or assignments.
-* @param {import('@typescript-eslint/types').TSESTree.Node|null|undefined} node
-* @param {string} resolverName
-* @returns {boolean}
-*/
-const hasNonEmptyResolverCall = (node, resolverName) => {
-	if (!node) return false;
-	switch (node.type) {
-		case "ArrayExpression":
-		case "ArrayPattern": return node.elements.some((element) => {
-			return hasNonEmptyResolverCall(element, resolverName);
-		});
-		case "ArrowFunctionExpression":
-		case "FunctionDeclaration":
-		case "FunctionExpression":
-			if (node.params[0]?.name === resolverName) return false;
-			return hasNonEmptyResolverCall(node.body, resolverName);
-		case "AssignmentExpression":
-		case "BinaryExpression":
-		case "LogicalExpression": return hasNonEmptyResolverCall(node.left, resolverName) || hasNonEmptyResolverCall(node.right, resolverName);
-		case "AssignmentPattern": return hasNonEmptyResolverCall(node.right, resolverName);
-		case "AwaitExpression":
-		case "SpreadElement":
-		case "UnaryExpression":
-		case "YieldExpression": return hasNonEmptyResolverCall(node.argument, resolverName);
-		case "BlockStatement":
-		case "ClassBody": return node.body.some((bodyNode) => {
-			return hasNonEmptyResolverCall(bodyNode, resolverName);
-		});
-		case "CallExpression":
-		case "OptionalCallExpression": return node.callee.name === resolverName && (node.arguments.length > 1 || node.arguments[0] !== void 0) || node.arguments.some((nde) => {
-			return nde.type === "Identifier" && nde.name === resolverName || hasNonEmptyResolverCall(nde, resolverName);
-		});
-		case "ChainExpression":
-		case "Decorator":
-		case "ExpressionStatement": return hasNonEmptyResolverCall(node.expression, resolverName);
-		case "ClassDeclaration":
-		case "ClassExpression": return hasNonEmptyResolverCall(node.body, resolverName);
-		case "ClassMethod":
-		case "MethodDefinition": return node.decorators && node.decorators.some((decorator) => {
-			return hasNonEmptyResolverCall(decorator, resolverName);
-		}) || node.computed && hasNonEmptyResolverCall(node.key, resolverName) || hasNonEmptyResolverCall(node.value, resolverName);
-		case "ClassProperty":
-		case "ObjectProperty":
-		case "Property":
-		case "PropertyDefinition": return node.computed && hasNonEmptyResolverCall(node.key, resolverName) || hasNonEmptyResolverCall(node.value, resolverName);
-		case "ConditionalExpression":
-		case "IfStatement": return hasNonEmptyResolverCall(node.test, resolverName) || hasNonEmptyResolverCall(node.consequent, resolverName) || hasNonEmptyResolverCall(node.alternate, resolverName);
-		case "DoWhileStatement":
-		case "ForInStatement":
-		case "ForOfStatement":
-		case "ForStatement":
-		case "LabeledStatement":
-		case "WhileStatement":
-		case "WithStatement": return hasNonEmptyResolverCall(node.body, resolverName);
-		case "Import":
-		case "ImportExpression": return hasNonEmptyResolverCall(node.source, resolverName);
-		case "MemberExpression":
-		case "OptionalMemberExpression": return hasNonEmptyResolverCall(node.object, resolverName) || hasNonEmptyResolverCall(node.property, resolverName);
-		case "ObjectExpression":
-		case "ObjectPattern": return node.properties.some((property) => {
-			return hasNonEmptyResolverCall(property, resolverName);
-		});
-		case "ObjectMethod":
- /* c8 ignore next 6 -- In Babel? */
-		return node.computed && hasNonEmptyResolverCall(node.key, resolverName) || node.arguments.some((nde) => {
-			return hasNonEmptyResolverCall(nde, resolverName);
-		});
-		case "ReturnStatement":
-			if (node.argument === null) return false;
-			return hasNonEmptyResolverCall(node.argument, resolverName);
-		case "SequenceExpression":
-		case "TemplateLiteral": return node.expressions.some((subExpression) => {
-			return hasNonEmptyResolverCall(subExpression, resolverName);
-		});
-		case "SwitchStatement": return node.cases.some((someCase) => {
-			return someCase.consequent.some((nde) => {
-				return hasNonEmptyResolverCall(nde, resolverName);
-			});
-		});
-		case "TaggedTemplateExpression": return hasNonEmptyResolverCall(node.quasi, resolverName);
-		case "TryStatement": return hasNonEmptyResolverCall(node.block, resolverName) || hasNonEmptyResolverCall(node.handler && node.handler.body, resolverName) || hasNonEmptyResolverCall(node.finalizer, resolverName);
-		case "VariableDeclaration": return node.declarations.some((nde) => {
-			return hasNonEmptyResolverCall(nde, resolverName);
-		});
-		case "VariableDeclarator": return hasNonEmptyResolverCall(node.id, resolverName) || hasNonEmptyResolverCall(node.init, resolverName);
-		default: return false;
-	}
-};
-/**
-* Checks if a Promise executor has no resolve value or an empty value.
-* An `undefined` resolve does not count.
-* @param {ESTreeOrTypeScriptNode} node
-* @param {boolean} anyPromiseAsReturn
-* @param {boolean} [allBranches]
-* @returns {boolean}
-*/
-const hasValueOrExecutorHasNonEmptyResolveValue = (node, anyPromiseAsReturn, allBranches) => {
-	const hasReturnMethod = allBranches ? (nde, promiseFilter) => {
-		let hasReturn;
-		try {
-			hasReturn = hasReturnValue(nde, true, promiseFilter);
-		} catch (error) {
-			// c8 ignore else
-			if (error.message === "Null return") return false;
-			/* c8 ignore next 3 */
-			throw error;
-		}
-		return Boolean(hasReturn && allBrancheshaveReturnValues(nde, promiseFilter));
-	} : (nde, promiseFilter) => {
-		return Boolean(hasReturnValue(nde, false, promiseFilter));
-	};
-	return hasReturnMethod(node, (prom) => {
-		if (anyPromiseAsReturn) return true;
-		if (isVoidPromise(prom)) return false;
-		const { body, params } = prom.arguments[0] || {};
-		if (!params?.length) return false;
-		const { name: resolverName } = params[0];
-		return hasNonEmptyResolverCall(body, resolverName);
-	});
-};
-
-//#endregion
-export { hasReturnValue, hasValueOrExecutorHasNonEmptyResolveValue };
-//# sourceMappingURL=hasReturnValue.js.map

package/dist/utils/hasReturnValue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hasReturnValue.js","names":[],"sources":["../../src/utils/hasReturnValue.js"],"sourcesContent":["/**\n * @typedef {import('estree').Node|\n *   import('@typescript-eslint/types').TSESTree.Node} ESTreeOrTypeScriptNode\n */\n\n/**\n * Checks if a node is a promise but has no resolve value or an empty value.\n * An `undefined` resolve does not count.\n * @param {ESTreeOrTypeScriptNode|undefined|null} node\n * @returns {boolean|undefined|null}\n */\nconst isNewPromiseExpression = (node) => {\n  return node && node.type === 'NewExpression' && node.callee.type === 'Identifier' &&\n    node.callee.name === 'Promise';\n};\n\n/**\n * @param {ESTreeOrTypeScriptNode|null|undefined} node\n * @returns {boolean}\n */\nconst isVoidPromise = (node) => {\n  return /** @type {import('@typescript-eslint/types').TSESTree.TSTypeReference} */ (node)?.typeArguments?.params?.[0]?.type === 'TSVoidKeyword'\n    /* c8 ignore next 5 */\n    // eslint-disable-next-line @stylistic/operator-linebreak -- c8\n    || /** @type {import('@typescript-eslint/types').TSESTree.TSTypeReference} */ (\n      node\n    // @ts-expect-error Ok\n    )?.typeParameters?.params?.[0]?.type === 'TSVoidKeyword';\n};\n\nconst undefinedKeywords = new Set([\n  'TSNeverKeyword', 'TSUndefinedKeyword', 'TSVoidKeyword',\n]);\n\n/**\n * Checks if a node has a return statement. Void return does not count.\n * @param {ESTreeOrTypeScriptNode|undefined|null} node\n * @param {boolean} [throwOnNullReturn]\n * @param {PromiseFilter} [promFilter]\n * @returns {boolean|undefined}\n */\n// eslint-disable-next-line complexity\nconst hasReturnValue = (node, throwOnNullReturn, promFilter) => {\n  if (!node) {\n    return false;\n  }\n\n  switch (node.type) {\n    case 'ArrowFunctionExpression':\n    case 'FunctionDeclaration':\n    case 'FunctionExpression': {\n      return 'expression' in node && node.expression && (!isNewPromiseExpression(\n        node.body,\n      ) || !isVoidPromise(node.body)) ||\n      hasReturnValue(node.body, throwOnNullReturn, promFilter);\n    }\n\n    case 'BlockStatement': {\n      return node.body.some((bodyNode) => {\n        return bodyNode.type !== 'FunctionDeclaration' && hasReturnValue(bodyNode, throwOnNullReturn, promFilter);\n      });\n    }\n\n    case 'DoWhileStatement':\n    case 'ForInStatement':\n    case 'ForOfStatement':\n\n    case 'ForStatement':\n\n    case 'LabeledStatement':\n    case 'WhileStatement':\n    case 'WithStatement': {\n      return hasReturnValue(node.body, throwOnNullReturn, promFilter);\n    }\n\n    case 'IfStatement': {\n      return hasReturnValue(node.consequent, throwOnNullReturn, promFilter) ||\n      hasReturnValue(node.alternate, throwOnNullReturn, promFilter);\n    }\n\n    case 'MethodDefinition':\n      return hasReturnValue(node.value, throwOnNullReturn, promFilter);\n    case 'ReturnStatement': {\n    // void return does not count.\n      if (node.argument === null) {\n        if (throwOnNullReturn) {\n          throw new Error('Null return');\n        }\n\n        return false;\n      }\n\n      if (promFilter && isNewPromiseExpression(node.argument)) {\n      // Let caller decide how to filter, but this is, at the least,\n      //   a return of sorts and truthy\n        return promFilter(node.argument);\n      }\n\n      return true;\n    }\n\n    case 'SwitchStatement': {\n      return node.cases.some(\n        (someCase) => {\n          return someCase.consequent.some((nde) => {\n            return hasReturnValue(nde, throwOnNullReturn, promFilter);\n          });\n        },\n      );\n    }\n\n    case 'TryStatement': {\n      return hasReturnValue(node.block, throwOnNullReturn, promFilter) ||\n      hasReturnValue(node.handler && node.handler.body, throwOnNullReturn, promFilter) ||\n      hasReturnValue(node.finalizer, throwOnNullReturn, promFilter);\n    }\n\n    case 'TSDeclareFunction':\n\n    case 'TSFunctionType':\n\n    case 'TSMethodSignature': {\n      const type = node?.returnType?.typeAnnotation?.type;\n      return type && !undefinedKeywords.has(type);\n    }\n\n    default: {\n      return false;\n    }\n  }\n};\n\n/**\n * Checks if a node has a return statement. Void return does not count.\n * @param {ESTreeOrTypeScriptNode|null|undefined} node\n * @param {PromiseFilter} promFilter\n * @returns {undefined|boolean|ESTreeOrTypeScriptNode}\n */\n// eslint-disable-next-line complexity\nconst allBrancheshaveReturnValues = (node, promFilter) => {\n  if (!node) {\n    return false;\n  }\n\n  switch (node.type) {\n    // case 'MethodDefinition':\n    //   return allBrancheshaveReturnValues(node.value, promFilter);\n    case 'ArrowFunctionExpression':\n    case 'FunctionDeclaration':\n    case 'FunctionExpression': {\n      return 'expression' in node && node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) ||\n      allBrancheshaveReturnValues(node.body, promFilter) ||\n      /** @type {import('@typescript-eslint/types').TSESTree.BlockStatement} */\n      (node.body).body.some((nde) => {\n        return nde.type === 'ReturnStatement';\n      });\n    }\n\n    case 'BlockStatement': {\n      const lastBodyNode = node.body.slice(-1)[0];\n      return allBrancheshaveReturnValues(lastBodyNode, promFilter);\n    }\n\n    case 'DoWhileStatement':\n    case 'WhileStatement':\n      if (\n      /**\n       * @type {import('@typescript-eslint/types').TSESTree.Literal}\n       */\n        (node.test).value === true\n      ) {\n      // If this is an infinite loop, we assume only one branch\n      //   is needed to provide a return\n        return hasReturnValue(node.body, false, promFilter);\n      }\n\n    // Fallthrough\n    case 'ForStatement':\n      if (node.test === null) {\n      // If this is an infinite loop, we assume only one branch\n      //   is needed to provide a return\n        return hasReturnValue(node.body, false, promFilter);\n      }\n\n    case 'ForInStatement':\n    case 'ForOfStatement':\n\n    case 'LabeledStatement':\n\n    case 'WithStatement': {\n      return allBrancheshaveReturnValues(node.body, promFilter);\n    }\n\n    case 'IfStatement': {\n      return allBrancheshaveReturnValues(node.consequent, promFilter) &&\n      allBrancheshaveReturnValues(node.alternate, promFilter);\n    }\n\n    case 'ReturnStatement': {\n    // void return does not count.\n      if (node.argument === null) {\n        return false;\n      }\n\n      if (promFilter && isNewPromiseExpression(node.argument)) {\n      // Let caller decide how to filter, but this is, at the least,\n      //   a return of sorts and truthy\n        return promFilter(node.argument);\n      }\n\n      return true;\n    }\n\n    case 'SwitchStatement': {\n      return /** @type {import('@typescript-eslint/types').TSESTree.SwitchStatement} */ (node).cases.every(\n        (someCase) => {\n          return !someCase.consequent.some((consNode) => {\n            return consNode.type === 'BreakStatement' ||\n            consNode.type === 'ReturnStatement' && consNode.argument === null;\n          });\n        },\n      );\n    }\n\n    case 'ThrowStatement': {\n      return true;\n    }\n\n    case 'TryStatement': {\n    // If `finally` returns, all return\n      return node.finalizer && allBrancheshaveReturnValues(node.finalizer, promFilter) ||\n      // Return in `try`/`catch` may still occur despite `finally`\n      allBrancheshaveReturnValues(node.block, promFilter) &&\n        (!node.handler ||\n          allBrancheshaveReturnValues(node.handler && node.handler.body, promFilter)) &&\n          (!node.finalizer || (() => {\n            try {\n              hasReturnValue(node.finalizer, true, promFilter);\n            } catch (error) {\n              if (/** @type {Error} */ (error).message === 'Null return') {\n                return false;\n              }\n              /* c8 ignore next 3 */\n              // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8\n              throw error;\n            }\n\n            // As long as not an explicit empty return, then return true\n            return true;\n          })());\n    }\n\n    case 'TSDeclareFunction':\n\n    case 'TSFunctionType':\n\n    case 'TSMethodSignature': {\n      const type = node?.returnType?.typeAnnotation?.type;\n      return type && !undefinedKeywords.has(type);\n    }\n\n    default: {\n      return false;\n    }\n  }\n};\n\n/**\n * @callback PromiseFilter\n * @param {ESTreeOrTypeScriptNode|undefined} node\n * @returns {boolean}\n */\n\n/**\n * Avoids further checking child nodes if a nested function shadows the\n * resolver, but otherwise, if name is used (by call or passed in as an\n * argument to another function), will be considered as non-empty.\n *\n * This could check for redeclaration of the resolver, but as such is\n * unlikely, we avoid the performance cost of checking everywhere for\n * (re)declarations or assignments.\n * @param {import('@typescript-eslint/types').TSESTree.Node|null|undefined} node\n * @param {string} resolverName\n * @returns {boolean}\n */\n// eslint-disable-next-line complexity\nconst hasNonEmptyResolverCall = (node, resolverName) => {\n  if (!node) {\n    return false;\n  }\n\n  // Arrow function without block\n  switch (node.type) {\n    case 'ArrayExpression':\n    case 'ArrayPattern':\n      return node.elements.some((element) => {\n        return hasNonEmptyResolverCall(element, resolverName);\n      });\n    case 'ArrowFunctionExpression':\n    case 'FunctionDeclaration':\n    case 'FunctionExpression': {\n    // Shadowing\n      if (/** @type {import('@typescript-eslint/types').TSESTree.Identifier} */ (\n        node.params[0]\n      )?.name === resolverName) {\n        return false;\n      }\n\n      return hasNonEmptyResolverCall(node.body, resolverName);\n    }\n\n    case 'AssignmentExpression':\n    case 'BinaryExpression':\n    case 'LogicalExpression': {\n      return hasNonEmptyResolverCall(node.left, resolverName) ||\n      hasNonEmptyResolverCall(node.right, resolverName);\n    }\n\n    case 'AssignmentPattern':\n      return hasNonEmptyResolverCall(node.right, resolverName);\n    case 'AwaitExpression':\n\n    case 'SpreadElement':\n    case 'UnaryExpression':\n    case 'YieldExpression':\n      return hasNonEmptyResolverCall(node.argument, resolverName);\n    case 'BlockStatement':\n    case 'ClassBody':\n      return node.body.some((bodyNode) => {\n        return hasNonEmptyResolverCall(bodyNode, resolverName);\n      });\n      /* c8 ignore next 2 -- In Babel? */\n    case 'CallExpression':\n      // @ts-expect-error Babel?\n    case 'OptionalCallExpression':\n      return /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */ (\n        node.callee\n      ).name === resolverName && (\n\n      // Implicit or explicit undefined\n        node.arguments.length > 1 || node.arguments[0] !== undefined\n      ) ||\n      node.arguments.some((nde) => {\n        // Being passed in to another function (which might invoke it)\n        return nde.type === 'Identifier' && nde.name === resolverName ||\n\n          // Handle nested items\n          hasNonEmptyResolverCall(nde, resolverName);\n      });\n\n    case 'ChainExpression':\n    case 'Decorator':\n\n    case 'ExpressionStatement':\n      return hasNonEmptyResolverCall(node.expression, resolverName);\n\n    case 'ClassDeclaration':\n\n    case 'ClassExpression':\n      return hasNonEmptyResolverCall(node.body, resolverName);\n      /* c8 ignore next 2 -- In Babel? */\n      // @ts-expect-error Babel?\n    case 'ClassMethod':\n\n    case 'MethodDefinition':\n      return node.decorators && node.decorators.some((decorator) => {\n        return hasNonEmptyResolverCall(decorator, resolverName);\n      }) ||\n      node.computed && hasNonEmptyResolverCall(node.key, resolverName) ||\n      hasNonEmptyResolverCall(node.value, resolverName);\n\n    /* c8 ignore next 2 -- In Babel? */\n      // @ts-expect-error Babel?\n    case 'ClassProperty':\n    /* c8 ignore next 2 -- In Babel? */\n    // @ts-expect-error Babel?\n    case 'ObjectProperty':\n    case 'Property':\n\n    case 'PropertyDefinition':\n      return node.computed && hasNonEmptyResolverCall(node.key, resolverName) ||\n      hasNonEmptyResolverCall(node.value, resolverName);\n    case 'ConditionalExpression':\n\n    case 'IfStatement': {\n      return hasNonEmptyResolverCall(node.test, resolverName) ||\n      hasNonEmptyResolverCall(node.consequent, resolverName) ||\n      hasNonEmptyResolverCall(node.alternate, resolverName);\n    }\n\n    case 'DoWhileStatement':\n    case 'ForInStatement':\n    case 'ForOfStatement':\n\n    case 'ForStatement':\n    case 'LabeledStatement':\n    case 'WhileStatement':\n    case 'WithStatement': {\n      return hasNonEmptyResolverCall(node.body, resolverName);\n    }\n\n    /* c8 ignore next 2 -- In Babel? */\n    // @ts-expect-error Babel?\n    case 'Import':\n\n    case 'ImportExpression':\n      return hasNonEmptyResolverCall(node.source, resolverName);\n      // ?.\n      /* c8 ignore next 2 -- In Babel? */\n    case 'MemberExpression':\n\n    // @ts-expect-error Babel?\n    case 'OptionalMemberExpression':\n      return hasNonEmptyResolverCall(node.object, resolverName) ||\n      hasNonEmptyResolverCall(node.property, resolverName);\n    case 'ObjectExpression':\n    case 'ObjectPattern':\n      return node.properties.some((property) => {\n        return hasNonEmptyResolverCall(property, resolverName);\n      });\n    /* c8 ignore next 2 -- In Babel? */\n      // @ts-expect-error Babel?\n    case 'ObjectMethod':\n    /* c8 ignore next 6 -- In Babel? */\n    // @ts-expect-error\n      return node.computed && hasNonEmptyResolverCall(node.key, resolverName) ||\n      // @ts-expect-error\n      node.arguments.some((nde) => {\n        return hasNonEmptyResolverCall(nde, resolverName);\n      });\n\n    case 'ReturnStatement': {\n      if (node.argument === null) {\n        return false;\n      }\n\n      return hasNonEmptyResolverCall(node.argument, resolverName);\n    }\n\n    // Comma\n    case 'SequenceExpression':\n\n    case 'TemplateLiteral':\n      return node.expressions.some((subExpression) => {\n        return hasNonEmptyResolverCall(subExpression, resolverName);\n      });\n\n    case 'SwitchStatement': {\n      return node.cases.some(\n        (someCase) => {\n          return someCase.consequent.some((nde) => {\n            return hasNonEmptyResolverCall(nde, resolverName);\n          });\n        },\n      );\n    }\n\n    case 'TaggedTemplateExpression':\n      return hasNonEmptyResolverCall(node.quasi, resolverName);\n\n    case 'TryStatement': {\n      return hasNonEmptyResolverCall(node.block, resolverName) ||\n      hasNonEmptyResolverCall(node.handler && node.handler.body, resolverName) ||\n      hasNonEmptyResolverCall(node.finalizer, resolverName);\n    }\n\n    case 'VariableDeclaration': {\n      return node.declarations.some((nde) => {\n        return hasNonEmptyResolverCall(nde, resolverName);\n      });\n    }\n\n    case 'VariableDeclarator': {\n      return hasNonEmptyResolverCall(node.id, resolverName) ||\n      hasNonEmptyResolverCall(node.init, resolverName);\n    }\n\n    /*\n  // Shouldn't need to parse literals/literal components, etc.\n\n  case 'Identifier':\n  case 'TemplateElement':\n  case 'Super':\n  // Exports not relevant in this context\n  */\n    default:\n      return false;\n  }\n};\n\n/**\n * Checks if a Promise executor has no resolve value or an empty value.\n * An `undefined` resolve does not count.\n * @param {ESTreeOrTypeScriptNode} node\n * @param {boolean} anyPromiseAsReturn\n * @param {boolean} [allBranches]\n * @returns {boolean}\n */\nconst hasValueOrExecutorHasNonEmptyResolveValue = (node, anyPromiseAsReturn, allBranches) => {\n  const hasReturnMethod = allBranches ?\n    /**\n     * @param {ESTreeOrTypeScriptNode} nde\n     * @param {PromiseFilter} promiseFilter\n     * @returns {boolean}\n     */\n    (nde, promiseFilter) => {\n      let hasReturn;\n      try {\n        hasReturn = hasReturnValue(nde, true, promiseFilter);\n      } catch (error) {\n        // c8 ignore else\n        if (/** @type {Error} */ (error).message === 'Null return') {\n          return false;\n        }\n        /* c8 ignore next 3 */\n        // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8\n        throw error;\n      }\n\n      // `hasReturn` check needed since `throw` treated as valid return by\n      //   `allBrancheshaveReturnValues`\n      return Boolean(hasReturn && allBrancheshaveReturnValues(nde, promiseFilter));\n    } :\n    /**\n     * @param {ESTreeOrTypeScriptNode} nde\n     * @param {PromiseFilter} promiseFilter\n     * @returns {boolean}\n     */\n    (nde, promiseFilter) => {\n      return Boolean(hasReturnValue(nde, false, promiseFilter));\n    };\n\n  return hasReturnMethod(node, (prom) => {\n    if (anyPromiseAsReturn) {\n      return true;\n    }\n\n    if (isVoidPromise(prom)) {\n      return false;\n    }\n\n    const {\n      body,\n      params,\n    } =\n    /**\n     * @type {import('@typescript-eslint/types').TSESTree.FunctionExpression|\n     * import('@typescript-eslint/types').TSESTree.ArrowFunctionExpression}\n     */ (\n      /** @type {import('@typescript-eslint/types').TSESTree.NewExpression} */ (\n          prom\n        ).arguments[0]\n      ) || {};\n\n    if (!params?.length) {\n      return false;\n    }\n\n    const {\n      name: resolverName,\n    } = /** @type {import('@typescript-eslint/types').TSESTree.Identifier} */ (\n      params[0]\n    );\n\n    return hasNonEmptyResolverCall(body, resolverName);\n  });\n};\n\nexport {\n  hasReturnValue,\n  hasValueOrExecutorHasNonEmptyResolveValue,\n};\n"],"mappings":"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"}