@depup/eslint-plugin-jsdoc 62.8.0-depup.0

package/src/exportParser.js

@@ -0,0 +1,973 @@
+import {
+  findJSDocComment,
+} from '@es-joy/jsdoccomment';
+import debugModule from 'debug';
+
+const debug = debugModule('requireExportJsdoc');
+
+/**
+ * @typedef {{
+ *   value: string
+ * }} ValueObject
+ */
+
+/**
+ * @typedef {{
+ *   type?: string,
+ *   value?: ValueObject|import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node,
+ *   props: {
+ *     [key: string]: CreatedNode|null,
+ *   },
+ *   special?: true,
+ *   globalVars?: CreatedNode,
+ *   exported?: boolean,
+ *   ANONYMOUS_DEFAULT?: import('eslint').Rule.Node
+ * }} CreatedNode
+ */
+
+/**
+ * @returns {CreatedNode}
+ */
+const createNode = function () {
+  return {
+    props: {},
+  };
+};
+
+/**
+ * @param {CreatedNode|null} symbol
+ * @returns {string|null}
+ */
+const getSymbolValue = function (symbol) {
+  /* c8 ignore next 3 */
+  if (!symbol) {
+    return null;
+  }
+
+  /* c8 ignore else */
+  if (symbol.type === 'literal') {
+    return /** @type {ValueObject} */ (symbol.value).value;
+  }
+  /* c8 ignore next 2 */
+  // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
+  return null;
+};
+
+/**
+ *
+ * @param {import('estree').Identifier} node
+ * @param {CreatedNode} globals
+ * @param {CreatedNode} scope
+ * @param {SymbolOptions} opts
+ * @returns {CreatedNode|null}
+ */
+const getIdentifier = function (node, globals, scope, opts) {
+  if (opts.simpleIdentifier) {
+    // Type is Identier for noncomputed properties
+    const identifierLiteral = createNode();
+    identifierLiteral.type = 'literal';
+    identifierLiteral.value = {
+      value: node.name,
+    };
+
+    return identifierLiteral;
+  }
+
+  /* c8 ignore next */
+  const block = scope || globals;
+
+  // As scopes are not currently supported, they are not traversed upwards recursively
+  if (block.props[node.name]) {
+    return block.props[node.name];
+  }
+
+  // Seems this will only be entered once scopes added and entered
+  /* c8 ignore next 3 */
+  if (globals.props[node.name]) {
+    return globals.props[node.name];
+  }
+
+  return null;
+};
+
+/**
+ * @callback CreateSymbol
+ * @param {import('eslint').Rule.Node|null} node
+ * @param {CreatedNode} globals
+ * @param {import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node|null} value
+ * @param {CreatedNode} [scope]
+ * @param {boolean|SymbolOptions} [isGlobal]
+ * @returns {CreatedNode|null}
+ */
+
+/** @type {CreateSymbol} */
+let createSymbol; // eslint-disable-line prefer-const
+
+/**
+ * @typedef {{
+ *   simpleIdentifier?: boolean
+ * }} SymbolOptions
+ */
+
+/**
+ *
+ * @param {import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node} node
+ * @param {CreatedNode} globals
+ * @param {CreatedNode} scope
+ * @param {SymbolOptions} [opt]
+ * @returns {CreatedNode|null}
+ */
+const getSymbol = function (node, globals, scope, opt) {
+  const opts = opt || {};
+  /* c8 ignore next */
+  switch (node.type) {
+    /* c8 ignore next 4 -- No longer needed? */
+    case 'ArrowFunctionExpression':
+
+    // Fallthrough
+    case 'ClassDeclaration':
+
+    case 'FunctionDeclaration':
+
+    case 'FunctionExpression':
+    case 'TSEnumDeclaration':
+    case 'TSInterfaceDeclaration':
+    case 'TSTypeAliasDeclaration': {
+      const val = createNode();
+      val.props.prototype = createNode();
+      val.props.prototype.type = 'object';
+      val.type = 'object';
+      val.value = node;
+
+      return val;
+    }
+
+    case 'AssignmentExpression': {
+      return createSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.left),
+        globals,
+        /** @type {import('eslint').Rule.Node} */
+        (node.right),
+        scope,
+        opts,
+      );
+    }
+
+    case 'ClassBody': {
+      const val = createNode();
+      for (const method of node.body) {
+        // StaticBlock
+        if (!('key' in method)) {
+          continue;
+        }
+
+        val.props[
+        /** @type {import('estree').Identifier} */ (
+          /** @type {import('estree').MethodDefinition} */ (
+              method
+            ).key
+          ).name
+        ] = createNode();
+        /** @type {{[key: string]: CreatedNode}} */ (val.props)[
+        /** @type {import('estree').Identifier} */ (
+          /** @type {import('estree').MethodDefinition} */ (
+              method
+            ).key
+          ).name
+        ].type = 'object';
+        /** @type {{[key: string]: CreatedNode}} */ (val.props)[
+        /** @type {import('estree').Identifier} */ (
+          /** @type {import('estree').MethodDefinition} */ (
+              method
+            ).key
+          ).name
+        ].value = /** @type {import('eslint').Rule.Node} */ (
+        /** @type {import('estree').MethodDefinition} */ (method).value
+        );
+      }
+
+      val.type = 'object';
+      val.value = node.parent;
+
+      return val;
+    }
+
+    case 'ClassExpression': {
+      return getSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.body),
+        globals,
+        scope,
+        opts,
+      );
+    }
+
+    case 'Identifier': {
+      return getIdentifier(node, globals, scope, opts);
+    }
+
+    case 'Literal': {
+      const val = createNode();
+      val.type = 'literal';
+      val.value = node;
+
+      return val;
+    }
+
+    case 'MemberExpression': {
+      const obj = getSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.object),
+        globals,
+        scope,
+        opts,
+      );
+      const propertySymbol = getSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.property),
+        globals,
+        scope,
+        {
+          simpleIdentifier: !node.computed,
+        },
+      );
+      const propertyValue = getSymbolValue(propertySymbol);
+
+      /* c8 ignore else */
+      if (obj && propertyValue && obj.props[propertyValue]) {
+        const block = obj.props[propertyValue];
+
+        return block;
+      }
+      /* c8 ignore next 11 */
+      /*
+    if (opts.createMissingProps && propertyValue) {
+      obj.props[propertyValue] = createNode();
+
+      return obj.props[propertyValue];
+    }
+    */
+      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
+      debug(`MemberExpression: Missing property ${
+      /** @type {import('estree').PrivateIdentifier} */ (node.property).name
+      }`);
+      /* c8 ignore next 2 */
+      return null;
+    }
+
+    case 'ObjectExpression': {
+      const val = createNode();
+      val.type = 'object';
+      for (const prop of node.properties) {
+        if ([
+        // @babel/eslint-parser
+          'ExperimentalSpreadProperty',
+
+          // typescript-eslint, espree, acorn, etc.
+          'SpreadElement',
+        ].includes(prop.type)) {
+          continue;
+        }
+
+        const propVal = getSymbol(
+        /** @type {import('eslint').Rule.Node} */ (
+          /** @type {import('estree').Property} */
+            (prop).value
+          ),
+          globals,
+          scope,
+          opts,
+        );
+        /* c8 ignore next 8 */
+        if (propVal) {
+          val.props[
+          /** @type {import('estree').PrivateIdentifier} */
+            (
+            /** @type {import('estree').Property} */ (prop).key
+            ).name
+          ] = propVal;
+        }
+      }
+
+      return val;
+    }
+  }
+  /* c8 ignore next 2 */
+  // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
+  return null;
+};
+
+/**
+ *
+ * @param {CreatedNode} block
+ * @param {string} name
+ * @param {CreatedNode|null} value
+ * @param {CreatedNode} globals
+ * @param {boolean|SymbolOptions|undefined} isGlobal
+ * @returns {void}
+ */
+const createBlockSymbol = function (block, name, value, globals, isGlobal) {
+  block.props[name] = value;
+  if (isGlobal && globals.props.window && globals.props.window.special) {
+    globals.props.window.props[name] = value;
+  }
+};
+
+createSymbol = function (node, globals, value, scope, isGlobal) {
+  const block = scope || globals;
+  /* c8 ignore next 3 */
+  if (!node) {
+    return null;
+  }
+
+  let symbol;
+  switch (node.type) {
+    case 'ClassDeclaration':
+      /* c8 ignore next */
+      // @ts-expect-error TS OK
+      // Fall through
+    case 'FunctionDeclaration': case 'TSEnumDeclaration':
+      /* c8 ignore next */
+      // @ts-expect-error TS OK
+      // Fall through
+    case 'TSInterfaceDeclaration': case 'TSTypeAliasDeclaration': {
+      const nde = /** @type {import('estree').ClassDeclaration} */ (node);
+      /* c8 ignore else */
+      if (nde.id && nde.id.type === 'Identifier') {
+        return createSymbol(
+        /** @type {import('eslint').Rule.Node} */ (nde.id),
+          globals,
+          node,
+          globals,
+        );
+      }
+      /* c8 ignore next 3 */
+      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
+      break;
+    }
+
+    case 'Identifier': {
+      const nde = /** @type {import('estree').Identifier} */ (node);
+      if (value) {
+        const valueSymbol = getSymbol(value, globals, block);
+        /* c8 ignore else */
+        if (valueSymbol) {
+          createBlockSymbol(block, nde.name, valueSymbol, globals, isGlobal);
+
+          return block.props[nde.name];
+        }
+        /* c8 ignore next 2 */
+        // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
+        debug('Identifier: Missing value symbol for %s', nde.name);
+      } else {
+        createBlockSymbol(block, nde.name, createNode(), globals, isGlobal);
+
+        return block.props[nde.name];
+      }
+      /* c8 ignore next 3 */
+      // eslint-disable-next-line @stylistic/padding-line-between-statements -- c8
+      break;
+    }
+
+    case 'MemberExpression': {
+      const nde = /** @type {import('estree').MemberExpression} */ (node);
+      symbol = getSymbol(
+      /** @type {import('eslint').Rule.Node} */ (nde.object), globals, block,
+      );
+
+      const propertySymbol = getSymbol(
+      /** @type {import('eslint').Rule.Node} */ (nde.property),
+        globals,
+        block,
+        {
+          simpleIdentifier: !nde.computed,
+        },
+      );
+      const propertyValue = getSymbolValue(propertySymbol);
+      if (symbol && propertyValue) {
+        createBlockSymbol(symbol, propertyValue, getSymbol(
+        /** @type {import('eslint').Rule.Node} */
+          (value), globals, block,
+        ), globals, isGlobal);
+        return symbol.props[propertyValue];
+      }
+
+      debug(
+        'MemberExpression: Missing symbol: %s',
+        /** @type {import('estree').Identifier} */ (
+          nde.property
+        ).name,
+      );
+      break;
+    }
+  }
+
+  return null;
+};
+
+/**
+ * Creates variables from variable definitions
+ * @param {import('eslint').Rule.Node} node
+ * @param {CreatedNode} globals
+ * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opts
+ * @returns {void}
+ */
+const initVariables = function (node, globals, opts) {
+  switch (node.type) {
+    case 'ExportNamedDeclaration': {
+      if (node.declaration) {
+        initVariables(
+        /** @type {import('eslint').Rule.Node} */
+          (node.declaration),
+          globals,
+          opts,
+        );
+      }
+
+      break;
+    }
+
+    case 'ExpressionStatement': {
+      initVariables(
+      /** @type {import('eslint').Rule.Node} */
+        (node.expression),
+        globals,
+        opts,
+      );
+      break;
+    }
+
+    case 'Program': {
+      for (const childNode of node.body) {
+        initVariables(
+        /** @type {import('eslint').Rule.Node} */
+          (childNode),
+          globals,
+          opts,
+        );
+      }
+
+      break;
+    }
+
+    case 'VariableDeclaration': {
+      for (const declaration of node.declarations) {
+      // let and const
+        const symbol = createSymbol(
+        /** @type {import('eslint').Rule.Node} */
+          (declaration.id),
+          globals,
+          null,
+          globals,
+        );
+        if (opts.initWindow && node.kind === 'var' && globals.props.window) {
+        // If var, also add to window
+          globals.props.window.props[
+          /** @type {import('estree').Identifier} */
+            (declaration.id).name
+          ] = symbol;
+        }
+      }
+
+      break;
+    }
+  }
+};
+
+/**
+ * Populates variable maps using AST
+ * @param {import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node} node
+ * @param {CreatedNode} globals
+ * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
+ * @param {true} [isExport]
+ * @returns {boolean}
+ */
+const mapVariables = function (node, globals, opt, isExport) {
+  /* c8 ignore next */
+  const opts = opt || {};
+  /* c8 ignore next */
+  switch (node.type) {
+    case 'AssignmentExpression': {
+      createSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.left),
+        globals,
+        /** @type {import('eslint').Rule.Node} */
+        (node.right),
+      );
+      break;
+    }
+
+    case 'ClassDeclaration': {
+      createSymbol(
+      /** @type {import('eslint').Rule.Node|null} */ (node.id),
+        globals,
+        /** @type {import('eslint').Rule.Node} */ (node.body),
+        globals,
+      );
+      break;
+    }
+
+    case 'ExportDefaultDeclaration': {
+      const symbol = createSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.declaration),
+        globals,
+        /** @type {import('eslint').Rule.Node} */
+        (node.declaration),
+      );
+      if (symbol) {
+        symbol.exported = true;
+        /* c8 ignore next 6 */
+      } else {
+      // if (!node.id) {
+        globals.ANONYMOUS_DEFAULT = /** @type {import('eslint').Rule.Node} */ (
+          node.declaration
+        );
+      }
+
+      break;
+    }
+
+    case 'ExportNamedDeclaration': {
+      if (node.declaration) {
+        if (node.declaration.type === 'VariableDeclaration') {
+          mapVariables(
+          /** @type {import('eslint').Rule.Node} */
+            (node.declaration),
+            globals,
+            opts,
+            true,
+          );
+        } else {
+          const symbol = createSymbol(
+          /** @type {import('eslint').Rule.Node} */
+            (node.declaration),
+            globals,
+            /** @type {import('eslint').Rule.Node} */
+            (node.declaration),
+          );
+          /* c8 ignore next 3 */
+          if (symbol) {
+            symbol.exported = true;
+          }
+        }
+      }
+
+      for (const specifier of node.specifiers) {
+        mapVariables(
+        /** @type {import('eslint').Rule.Node} */
+          (specifier),
+          globals,
+          opts,
+        );
+      }
+
+      break;
+    }
+
+    case 'ExportSpecifier': {
+      const symbol = getSymbol(
+      /** @type {import('eslint').Rule.Node} */
+        (node.local),
+        globals,
+        globals,
+      );
+      /* c8 ignore next 3 */
+      if (symbol) {
+        symbol.exported = true;
+      }
+
+      break;
+    }
+
+    case 'ExpressionStatement': {
+      mapVariables(
+      /** @type {import('eslint').Rule.Node} */
+        (node.expression),
+        globals,
+        opts,
+      );
+      break;
+    }
+
+    case 'FunctionDeclaration':
+
+    case 'TSTypeAliasDeclaration': {
+    /* c8 ignore next 10 */
+      if (/** @type {import('estree').Identifier} */ (node.id).type === 'Identifier') {
+        createSymbol(
+        /** @type {import('eslint').Rule.Node} */
+          (node.id),
+          globals,
+          node,
+          globals,
+          true,
+        );
+      }
+
+      break;
+    }
+
+    case 'Program': {
+      if (opts.ancestorsOnly) {
+        return false;
+      }
+
+      for (const childNode of node.body) {
+        mapVariables(
+        /** @type {import('eslint').Rule.Node} */
+          (childNode),
+          globals,
+          opts,
+        );
+      }
+
+      break;
+    }
+
+    case 'VariableDeclaration': {
+      for (const declaration of node.declarations) {
+        const isGlobal = Boolean(opts.initWindow && node.kind === 'var' && globals.props.window);
+        const symbol = createSymbol(
+        /** @type {import('eslint').Rule.Node} */
+          (declaration.id),
+          globals,
+          /** @type {import('eslint').Rule.Node} */
+          (declaration.init),
+          globals,
+          isGlobal,
+        );
+        if (symbol && isExport) {
+          symbol.exported = true;
+        }
+      }
+
+      break;
+    }
+
+    default: {
+    /* c8 ignore next */
+      return false;
+    }
+  }
+
+  return true;
+};
+
+/**
+ *
+ * @param {import('eslint').Rule.Node} node
+ * @param {CreatedNode|ValueObject|string|undefined|
+ *   import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node} block
+ * @param {(CreatedNode|ValueObject|string|
+ *   import('eslint').Rule.Node|import('@typescript-eslint/types').TSESTree.Node)[]} [cache]
+ * @returns {boolean}
+ */
+const findNode = function (node, block, cache) {
+  let blockCache = cache || [];
+  if (!block || blockCache.includes(block)) {
+    return false;
+  }
+
+  blockCache = blockCache.slice();
+  blockCache.push(block);
+
+  if (
+    typeof block === 'object' &&
+    'type' in block &&
+    (block.type === 'object' || block.type === 'MethodDefinition') &&
+    block.value === node
+  ) {
+    return true;
+  }
+
+  if (typeof block !== 'object') {
+    return false;
+  }
+
+  const props = ('props' in block && block.props) || ('body' in block && block.body);
+  for (const propval of Object.values(props || {})) {
+    if (Array.isArray(propval)) {
+      /* c8 ignore next 5 */
+      if (propval.some((val) => {
+        return findNode(node, val, blockCache);
+      })) {
+        return true;
+      }
+    } else if (findNode(node, propval, blockCache)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+const exportTypes = new Set([
+  'ExportDefaultDeclaration', 'ExportNamedDeclaration',
+]);
+const ignorableNestedTypes = new Set([
+  'ArrowFunctionExpression', 'FunctionDeclaration', 'FunctionExpression',
+]);
+
+/**
+ * @param {import('eslint').Rule.Node} nde
+ * @returns {import('eslint').Rule.Node|false}
+ */
+const getExportAncestor = function (nde) {
+  /** @type {import('eslint').Rule.Node|null} */
+  let node = nde;
+  let idx = 0;
+  const ignorableIfDeep = ignorableNestedTypes.has(nde?.type);
+  while (node) {
+    // Ignore functions nested more deeply than say `export default function () {}`
+    if (idx >= 2 && ignorableIfDeep) {
+      break;
+    }
+
+    if (exportTypes.has(node.type)) {
+      return node;
+    }
+
+    node = node.parent;
+    idx++;
+  }
+
+  return false;
+};
+
+const canBeExportedByAncestorType = new Set([
+  'ClassProperty',
+  'Method',
+  'PropertyDefinition',
+  'TSMethodSignature',
+  'TSPropertySignature',
+]);
+
+const canExportChildrenType = new Set([
+  'ClassBody',
+  'ClassDeclaration',
+  'ClassDefinition',
+  'ClassExpression',
+  'Program',
+  'TSInterfaceBody',
+  'TSInterfaceDeclaration',
+  'TSTypeAliasDeclaration',
+  'TSTypeLiteral',
+  'TSTypeParameterInstantiation',
+  'TSTypeReference',
+]);
+
+/**
+ * @param {import('eslint').Rule.Node} nde
+ * @returns {false|import('eslint').Rule.Node}
+ */
+const isExportByAncestor = function (nde) {
+  if (!canBeExportedByAncestorType.has(nde.type)) {
+    return false;
+  }
+
+  let node = nde.parent;
+  while (node) {
+    if (exportTypes.has(node.type)) {
+      return node;
+    }
+
+    if (!canExportChildrenType.has(node.type)) {
+      return false;
+    }
+
+    node = node.parent;
+  }
+
+  return false;
+};
+
+/**
+ *
+ * @param {CreatedNode} block
+ * @param {import('eslint').Rule.Node} node
+ * @param {CreatedNode[]} [cache] Currently unused
+ * @returns {boolean}
+ */
+const findExportedNode = function (block, node, cache) {
+  /* c8 ignore next 3 */
+  if (block === null) {
+    return false;
+  }
+
+  const blockCache = cache || [];
+  const {
+    props,
+  } = block;
+  for (const propval of Object.values(props)) {
+    const pval = /** @type {CreatedNode} */ (propval);
+    blockCache.push(pval);
+    if (pval.exported && (node === pval.value || findNode(node, pval.value))) {
+      return true;
+    }
+
+    // No need to check `propval` for exported nodes as ESM
+    //  exports are only global
+  }
+
+  return false;
+};
+
+/**
+ *
+ * @param {import('eslint').Rule.Node} node
+ * @param {CreatedNode} globals
+ * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
+ * @returns {boolean}
+ */
+const isNodeExported = function (node, globals, opt) {
+  const moduleExports = globals.props.module?.props?.exports;
+  if (
+    opt.initModuleExports && moduleExports && findNode(node, moduleExports)
+  ) {
+    return true;
+  }
+
+  if (opt.initWindow && globals.props.window && findNode(node, globals.props.window)) {
+    return true;
+  }
+
+  if (opt.esm && findExportedNode(globals, node)) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+ *
+ * @param {import('eslint').Rule.Node} node
+ * @param {CreatedNode} globalVars
+ * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opts
+ * @returns {boolean}
+ */
+const parseRecursive = function (node, globalVars, opts) {
+  // Iterate from top using recursion - stop at first processed node from top
+  if (node.parent && parseRecursive(node.parent, globalVars, opts)) {
+    return true;
+  }
+
+  return mapVariables(node, globalVars, opts);
+};
+
+/**
+ *
+ * @param {import('eslint').Rule.Node} ast
+ * @param {import('eslint').Rule.Node} node
+ * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
+ * @returns {CreatedNode}
+ */
+const parse = function (ast, node, opt) {
+  /* c8 ignore next 6 */
+  const opts = opt || {
+    ancestorsOnly: false,
+    esm: true,
+    initModuleExports: true,
+    initWindow: true,
+  };
+
+  const globalVars = createNode();
+  if (opts.initModuleExports) {
+    globalVars.props.module = createNode();
+    globalVars.props.module.props.exports = createNode();
+    globalVars.props.exports = globalVars.props.module.props.exports;
+  }
+
+  if (opts.initWindow) {
+    globalVars.props.window = createNode();
+    globalVars.props.window.special = true;
+  }
+
+  if (opts.ancestorsOnly) {
+    parseRecursive(node, globalVars, opts);
+  } else {
+    initVariables(ast, globalVars, opts);
+    mapVariables(ast, globalVars, opts);
+  }
+
+  return {
+    globalVars,
+    props: {},
+  };
+};
+
+const accessibilityNodes = new Set([
+  'MethodDefinition',
+  'PropertyDefinition',
+]);
+
+/**
+ *
+ * @param {import('eslint').Rule.Node} node
+ * @returns {boolean}
+ */
+const isPrivate = (node) => {
+  return accessibilityNodes.has(node.type) &&
+    (
+      'accessibility' in node &&
+      node.accessibility !== 'public' && node.accessibility !== undefined
+    ) ||
+  'key' in node &&
+    node.key.type === 'PrivateIdentifier';
+};
+
+/**
+ *
+ * @param {import('eslint').Rule.Node} node
+ * @param {import('eslint').SourceCode} sourceCode
+ * @param {import('./rules/requireJsdoc.js').RequireJsdocOpts} opt
+ * @param {import('./iterateJsdoc.js').Settings} settings
+ * @returns {boolean}
+ */
+const isUncommentedExport = function (node, sourceCode, opt, settings) {
+  // console.log({node});
+  // Optimize with ancestor check for esm
+  if (opt.esm) {
+    if (isPrivate(node) ||
+      node.parent && isPrivate(node.parent)) {
+      return false;
+    }
+
+    const exportNode = getExportAncestor(node);
+
+    // Is export node comment
+    if (exportNode && !findJSDocComment(exportNode, sourceCode, settings)) {
+      return true;
+    }
+
+    /**
+     * Some typescript types are not in variable map, but inherit exported (interface property and method)
+     */
+    if (
+      isExportByAncestor(node) &&
+      !findJSDocComment(node, sourceCode, settings)
+    ) {
+      return true;
+    }
+  }
+
+  const ast = /** @type {unknown} */ (sourceCode.ast);
+
+  const parseResult = parse(
+    /** @type {import('eslint').Rule.Node} */
+    (ast),
+    node,
+    opt,
+  );
+
+  return isNodeExported(
+    node, /** @type {CreatedNode} */ (parseResult.globalVars), opt,
+  );
+};
+
+export default {
+  isUncommentedExport,
+  parse,
+};