A standalone docblock parser

Downloads in past


1.0.08 years ago9 years agoMinified + gzip package size for docblock-parser in KB


docblock-parser Build Status
A line based doc block parser.


I wasn't able to find a standalone, not opinionated docblock parser. Most parsers seem to make fixed assumptions about the value of a tag. This is a slightly less opinionated parser. It allows you to specify which parts of a tag make up its value, on a line basis.

Quick example

> var docblockParser = require('docblock-parser');
> docblockParser.parse('/** @type {Object} */');
{ text: '',
  tags: { type: '{Object} Description' } }


The parser is built around the idea of consuming lines. If the parser encounters a line that starts with a tag pattern (@tagname), it delegates the consumption of the following lines to a tag specific consumer or the default consumer. If the line doesn't start with a tag, it delegates to the text consumer.
A consumer is a function that accepts a Docblock object and returns a value which is associated with the tag or free text.
A Docblock object is just a stack of lines, with which a consumer can .peek() at the current line or .pop() it from the stack to consume it. A consumer .pop()s lines until a condition is met (or there no lines left).


npm install docblock-parser



This parses docstring with the default configuration (defaultConfig.js) which provides sensible defaults for jsdoc tags.


Allows you to specific your own consumers and tags.
Type: RegExp
The pattern to validate a docblock. Defaults to /^\/\*\*|^\s*\* ?/m.
Type: RegExp
The start of docblock. The match will be removed before parsing. Defaults to /^\s*\/\*\*\s?/.
Type: RegExp
The end of docblock. The match will be removed before parsing. Defaults to /\*\/\s*$/.
Type: RegExp
Start of a line in a docblock. The match will be removed while parsing aline. Defaults to /^\s*\* ?/.
Type: function
A consumer for all free text inside the doc block. I.e. text not associated with a specific tag.
Type: function
The fallback consumer used for tags not listed in config.tags.
Type: object
A tag name -> consumer mapping that allows to use different strategies for different tags.
Returns {text: (Array|string), tags {tagname: (Array|?), ...}}
Is an array if the doc block contains multiple sections of free text, else a single string.
Is an object of tagname -> value mappings. The type of the value depends on the consumer being used for the tag, but it will definitely be an array if the tag appeared multiple times in the doc block (e.g. @param).


Custom Tags

var docblockParser = require('./');
var docstring = [
  ' * Some free text',
  ' *',
  ' * @public',
  ' * @extends',
  ' * SuperLongClassName',
  ' * @multiline-example',
  ' * E.g. for example code',
  ' *',
  ' *     var foo = bar;',
  ' *',
  ' * With description.',
  ' *',
  ' * @param {string} foo',
  ' * @param {number} bar',
  ' * @returns {boolean} Some desciption',
  ' */',

// config.text and config.default is provided through the default config
var result = docblockParser({
  tags: {
    public: docblockParser.booleanTag,
    extends: docblockParser.singleParameterTag,
    'multiline-example': docblockParser.multilineTilTag,
    param: docblockParser.multilineTilTag,
    returns: docblockParser.multilineTilTag,

  text: 'Some free text',
  tags: {
    public: true,
    extends: 'SuperLongClassName',
    'multiline-example': 'E.g. for example code\n\n    var foo = bar;\n\nWith description.',
    param: [ '{string} foo', '{number} bar' ],
    returns: '{boolean} Some desciption'
Note that there is no line break after "Some free text" and "With description". If you are using the built-in default consumer (consumeTil)(which all of the built-in consumer do), leading and trailing lines will be removed form the value.
In this example we specified our own tag consumers. We could have also used the default ones and just called docblockParser.parse(docstring).

Custom format

var docblockParser = require('./');
var docstring = '{##\nSome free text\n@memberOf test\n##}';
var result = docblockParser({
	docBlockPattern: /\{##([^#]*)##\}/ig,
	startPattern: /^\s*\{##\s?/,
	endPattern: /##\}\s*$/

  text: 'Some free text',
  tags: {
    memberOf: 'test'

Built-in consumers

The parser comes with consumers for the most common use cases:
  • multilineTilTag
- Consumes as many lines until it encounters a line starting with the
@tagname` pattern.
- Returns: The collected lines. This is usually the safest to use, since it
may not always be possible to format the values of tags in a specific way.
  • multilineTilEmptyLineOrTag
- Consumes as many lines until it encounters an empty line or a tag. - Returns: The collected lines.
  • booleanTag
- Consumes just the current line. - Returns: True. The mere fact that the function is called means that the tag
  • singleParameterTag
- Consumes lines until it finds a non-empty line. - Returns: The collected line. That is the value of the tag.
  • multiParameterTag(delimiter)
- Based on multilineTilEmptyLineOrTag - Returns: Returns an array of values. The values come from
`multilineTilEmptyLineOrTag` split by `delimiter`.