Programmatic API

/**
 * Returns markdown documentation from jsdoc-annotated source code
 * @param {RenderOptions} [options={}] - Configuration options
 * @returns {Promise<string>} The rendered markdown documentation
 */
async function render(options = {});

import jsdoc2md from 'jsdoc-to-markdown';

// Basic file processing
const docs = await jsdoc2md.render({ files: 'lib/*.js' });

// Process source code directly
const docs = await jsdoc2md.render({
  source: `
    /**
     * Adds two numbers together.
     * @param {number} a - First number
     * @param {number} b - Second number
     * @returns {number} Sum of a and b
     */
    function add(a, b) {
      return a + b;
    }
  `
});

// Custom template and formatting
const docs = await jsdoc2md.render({
  files: 'src/*.js',
  template: '{{>main}}',
  'heading-depth': 1,
  'example-lang': 'javascript',
  separators: true
});

// Use pre-fetched template data
const templateData = await jsdoc2md.getTemplateData({ files: 'src/*.js' });
const docs = await jsdoc2md.render({ data: templateData });

/**
 * Returns the template data (jsdoc-parse output) which is fed into the output template
 * @param {TemplateDataOptions} [options={}] - Configuration options
 * @returns {Promise<object[]>} The parsed template data
 */
async function getTemplateData(options = {});

import jsdoc2md from 'jsdoc-to-markdown';

// Get processed template data
const templateData = await jsdoc2md.getTemplateData({
  files: ['lib/module-a.js', 'lib/module-b.js']
});

// Use with custom processing
const templateData = await jsdoc2md.getTemplateData({ files: 'src/*.js' });
// Filter or modify templateData as needed
const filteredData = templateData.filter(item => !item.ignore);
const docs = await jsdoc2md.render({ data: filteredData });

/**
 * Returns raw data direct from the underlying jsdoc3
 * @param {JsdocDataOptions} options - Configuration options (required)
 * @returns {Promise<object[]>} Raw JSDoc data
 */
async function getJsdocData(options);

import jsdoc2md from 'jsdoc-to-markdown';

// Get raw JSDoc data
const rawData = await jsdoc2md.getJsdocData({
  files: 'src/**/*.js'
});

// Process with custom JSDoc configuration
const rawData = await jsdoc2md.getJsdocData({
  configure: './jsdoc.conf.json'
});

// Disable caching for development
const rawData = await jsdoc2md.getJsdocData({
  files: 'src/*.js',
  'no-cache': true
});

/**
 * Clears the cache stored in the system's temporary directory
 * @returns {Promise<void>}
 */
async function clear();

import jsdoc2md from 'jsdoc-to-markdown';

// Clear cache before processing
await jsdoc2md.clear();

// Clear cache for troubleshooting
try {
  const docs = await jsdoc2md.render({ files: 'src/*.js' });
} catch (error) {
  // Clear cache and retry
  await jsdoc2md.clear();
  const docs = await jsdoc2md.render({ files: 'src/*.js' });
}

/**
 * Returns all jsdoc namepaths found in the supplied source code
 * @param {NamepathOptions} options - Configuration options
 * @returns {Promise<object>} Namepaths organized by kind
 */
async function getNamepaths(options);

import jsdoc2md from 'jsdoc-to-markdown';

// Get all namepaths
const namepaths = await jsdoc2md.getNamepaths({
  files: 'src/*.js'
});

/* Returns object like:
{
  "module": ["module:utils", "module:helpers"],
  "class": ["MyClass", "DataProcessor"],
  "function": ["processData", "formatOutput"],
  "constant": ["DEFAULT_CONFIG", "VERSION"],
  "member": ["MyClass.prototype.value"],
  "namespace": ["Utils"],
  "constructor": ["MyClass"],
  "mixin": ["EventMixin"],
  "event": ["data:loaded"],
  "typedef": ["DataConfig", "ProcessResult"],
  "external": ["jQuery", "lodash"]
}
*/

// Use for documentation analysis
const namepaths = await jsdoc2md.getNamepaths({ files: 'lib/*.js' });
const functionCount = namepaths.function.length;
const classCount = namepaths.class.length;
console.log(`Found ${functionCount} functions and ${classCount} classes`);

interface RenderOptions extends TemplateDataOptions {
  /** Raw template data to use instead of parsing files */
  data?: object[];
  /** Custom handlebars template for full control over output */
  template?: string;
  /** Initial heading depth (default: 2) */
  'heading-depth'?: number;
  /** Default language for @example blocks */
  'example-lang'?: string;
  /** Installed package containing helper/partial overrides */
  plugin?: string | string[];
  /** Handlebars helper files to override defaults */
  helper?: string | string[];
  /** Handlebars partial files to override defaults */
  partial?: string | string[];
  /** Format identifier names as code (wrap in backticks) */
  'name-format'?: boolean;
  /** Disable GitHub-flavored markdown */
  'no-gfm'?: boolean;
  /** Add horizontal rule breaks between identifiers */
  separators?: boolean;
  /** Module index format: none, grouped, table, dl */
  'module-index-format'?: string;
  /** Global index format: none, grouped, table, dl */
  'global-index-format'?: string;
  /** Parameter list format: list, table */
  'param-list-format'?: string;
  /** Property list format: list, table */
  'property-list-format'?: string;
  /** Member index format: grouped, list */
  'member-index-format'?: string;
  /** Render URL links in plain text, others in monospace */
  'clever-links'?: boolean;
  /** Render all links in monospace */
  'monospace-links'?: boolean;
  /** EOL character: posix, win32 */
  EOL?: string;
}

interface TemplateDataOptions extends JsdocDataOptions {}

interface JsdocDataOptions {
  /** Disable caching for this invocation */
  'no-cache'?: boolean;
  /** File paths or glob patterns to process */
  files?: string | string[];
  /** Source code string to process */
  source?: string;
  /** Path to JSDoc configuration file */
  configure?: string;
}

interface NamepathOptions extends TemplateDataOptions {}

import jsdoc2md from 'jsdoc-to-markdown';

try {
  const docs = await jsdoc2md.render({ files: 'src/*.js' });
} catch (error) {
  if (error.message.includes('ENOENT')) {
    console.error('Files not found');
  } else if (error.message.includes('jsdoc')) {
    console.error('JSDoc parsing error:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}