-
-
+
+
+
-
<%- options.name %>
-
<%- options.version %>
+
<%- config['project-name'] %>
+
<%- config['project-version'] %>
@@ -37,7 +42,7 @@
Static members
.<%- member.name %>
Instance members
+ #<%- member.name %>
+
+ <% } %>
+ <% if (doc.members.inner && doc.members.inner.length) { %>
+
+ Inner members
#<%- member.name %>
Events
<% doc.members.events.forEach(function(member) { %>
ⓔ <%- member.name %>
-
+
<% docs.forEach(function(s) { %>
- <% if (s.kind !== 'note') { %>
- <%= renderSection({
- section: s,
- renderSection: renderSection,
- renderSectionList: renderSectionList
- }) %>
- <% } else { %>
+ <% if (s.kind === 'note' && !s.children) { %>
<%=renderNote({ note: s })%>
+ <% } else { %>
+ <%= renderSection({
+ section: s,
+ renderSection: renderSection,
+ renderSectionList: renderSectionList,
+ renderParamProperty: renderParamProperty
+ }) %>
<% } %>
<% }) %>
-
+
diff --git a/src/default_theme/index.js b/src/default_theme/index.js
new file mode 100644
index 000000000..19eace3be
--- /dev/null
+++ b/src/default_theme/index.js
@@ -0,0 +1,142 @@
+import fs from 'fs/promises';
+import path from 'path';
+import template from 'lodash/template.js';
+import GithubSlugger from 'github-slugger';
+import { util } from '../index.js';
+import hljs from 'highlight.js';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const { LinkerStack, createFormatters } = util;
+
+async function copyDir(sorce, dest) {
+ await fs.mkdir(dest, { recursive: true });
+ let entries = await fs.readdir(sorce, { withFileTypes: true });
+
+ for (let entry of entries) {
+ let srcPath = path.join(sorce, entry.name);
+ let destPath = path.join(dest, entry.name);
+
+ entry.isDirectory()
+ ? await copyDir(srcPath, destPath)
+ : await fs.copyFile(srcPath, destPath);
+ }
+}
+
+function isFunction(section) {
+ return (
+ section.kind === 'function' ||
+ (section.kind === 'typedef' &&
+ section.type &&
+ section.type.type === 'NameExpression' &&
+ section.type.name === 'Function')
+ );
+}
+
+const slugger = new GithubSlugger();
+const slugs = {};
+
+function getSlug(str) {
+ if (slugs[str] === undefined) {
+ slugs[str] = slugger.slug(str);
+ }
+ return slugs[str];
+}
+
+export default async function (comments, config) {
+ var linkerStack = new LinkerStack(config).namespaceResolver(
+ comments,
+ function (namespace) {
+ return '#' + getSlug(namespace);
+ }
+ );
+
+ var formatters = createFormatters(linkerStack.link);
+
+ hljs.configure(config.hljs || {});
+
+ var sharedImports = {
+ imports: {
+ slug(str) {
+ return getSlug(str);
+ },
+ shortSignature(section) {
+ var prefix = '';
+ if (section.kind === 'class') {
+ prefix = 'new ';
+ } else if (!isFunction(section)) {
+ return section.name;
+ }
+ return prefix + section.name + formatters.parameters(section, true);
+ },
+ signature(section) {
+ var returns = '';
+ var prefix = '';
+ if (section.kind === 'class') {
+ prefix = 'new ';
+ } else if (!isFunction(section)) {
+ return section.name;
+ }
+ if (section.returns.length) {
+ returns = ': ' + formatters.type(section.returns[0].type);
+ }
+ return prefix + section.name + formatters.parameters(section) + returns;
+ },
+ md(ast, inline) {
+ if (
+ inline &&
+ ast &&
+ ast.children.length &&
+ ast.children[0].type === 'paragraph'
+ ) {
+ ast = {
+ type: 'root',
+ children: ast.children[0].children.concat(ast.children.slice(1))
+ };
+ }
+ return formatters.markdown(ast);
+ },
+ formatType: formatters.type,
+ autolink: formatters.autolink,
+ highlight(example) {
+ if (config.hljs && config.hljs.highlightAuto) {
+ return hljs.highlightAuto(example).value;
+ }
+ return hljs.highlight(example, { language: 'js' }).value;
+ }
+ }
+ };
+
+ sharedImports.imports.renderSectionList = template(
+ await fs.readFile(path.join(__dirname, 'section_list._'), 'utf8'),
+ sharedImports
+ );
+ sharedImports.imports.renderSection = template(
+ await fs.readFile(path.join(__dirname, 'section._'), 'utf8'),
+ sharedImports
+ );
+ sharedImports.imports.renderNote = template(
+ await fs.readFile(path.join(__dirname, 'note._'), 'utf8'),
+ sharedImports
+ );
+ sharedImports.imports.renderParamProperty = template(
+ await fs.readFile(path.join(__dirname, 'paramProperty._'), 'utf8'),
+ sharedImports
+ );
+
+ var pageTemplate = template(
+ await fs.readFile(path.join(__dirname, 'index._'), 'utf8'),
+ sharedImports
+ );
+
+ const string = pageTemplate({ docs: comments, config });
+
+ if (!config.output) {
+ return string;
+ }
+
+ await copyDir(__dirname + '/assets/', config.output + '/assets/');
+ await fs.writeFile(config.output + '/index.html', string, 'utf8');
+}
diff --git a/default_theme/note._ b/src/default_theme/note._
similarity index 68%
rename from default_theme/note._
rename to src/default_theme/note._
index f98b2a444..cebebc13c 100644
--- a/default_theme/note._
+++ b/src/default_theme/note._
@@ -1,10 +1,10 @@
-
+
<%- note.name %>
<% if (note.description) { %>
<%= md(note.description) %>
<% } %>
-
+
\ No newline at end of file
diff --git a/src/default_theme/paramProperty._ b/src/default_theme/paramProperty._
new file mode 100644
index 000000000..5291b2be3
--- /dev/null
+++ b/src/default_theme/paramProperty._
@@ -0,0 +1,15 @@
+
+ <%- property.name %> <%= formatType(property.type) %>
+ <% if (property.default) { %>
+ (default <%- property.default %>)
+ <% } %><%= md(property.description, true) %>
+<% if(property.properties && property.properties.length) { %>
+ <% property.properties.forEach(function(childProperty) { %>
+ <%= renderParamProperty({
+ property: childProperty,
+ renderParamProperty: renderParamProperty
+ }) %>
+ <% }) %>
+<% } %>
diff --git a/default_theme/section._ b/src/default_theme/section._
similarity index 69%
rename from default_theme/section._
rename to src/default_theme/section._
index 06f7bd2f4..cd30107e5 100644
--- a/default_theme/section._
+++ b/src/default_theme/section._
@@ -8,18 +8,22 @@
<% } %>
<% if (section.context && section.context.github) { %>
-
- <%= section.context.path %>
+
+ <%= section.context.github.path %>
<% } %>
<% } %>
<%= md(section.description) %>
-
-
<%= signature(section) %>
-
- <% if (section.augments) { %>
+
<%= signature(section) %>
+ <% if (section.type) { %>
+
+ Type:
+ <%= formatType(section.type) %>
+
+ <% } %>
+ <% if (section.augments && section.augments.length) { %>
Extends
<% if (section.augments) { %>
@@ -30,13 +34,14 @@
<% } %>
+ <% if (section.deprecated) { %>
Deprecated: <%= md(section.deprecated, true) %>
<% }%>
<% if (section.version) { %>
Version: <%- section.version %>
<% }%>
<% if (section.license) { %>
License: <%- section.license %>
<% }%>
<% if (section.author) { %>
Author: <%- section.author %>
<% }%>
- <% if (section.copyright) { %>
Copyright: <%- section.copyright %>
<% }%>
+ <% if (section.copyright) { %>
Copyright: <%= md(section.copyright, true) %>
<% }%>
<% if (section.since) { %>
Since: <%- section.since %>
<% }%>
- <% if (section.params) { %>
+ <% if (section.params && section.params.length) { %>
Parameters
<% section.params.forEach(function(param) { %>
@@ -46,7 +51,7 @@
= <%- param.default %><% } %>)
<%= md(param.description, true) %>
- <% if (param.properties) { %>
+ <% if (param.properties && param.properties.length) { %>
<% param.properties.forEach(function(property) { %>
-
- <%- property.name %> <%= formatType(property.type) %>
- <% if (property.default) { %>
- (default <%- property.default %>)
- <% } %><%= md(property.description, true) %>
+ <%= renderParamProperty({
+ property: property,
+ renderParamProperty: renderParamProperty
+ }) %>
<% }) %>
@@ -76,7 +78,7 @@
<% } %>
- <% if (section.properties) { %>
+ <% if (section.properties && section.properties.length) { %>
Properties
<% section.properties.forEach(function(property) { %>
@@ -87,7 +89,7 @@
<% } %><% if (property.description) {
%>: <%= md(property.description, true) %><%
} %>
- <% if (property.properties) { %>
+ <% if (property.properties && property.properties.length) { %>
<% property.properties.forEach(function(property) { %>
<%- property.name %> <%= formatType(property.type) %>
@@ -103,7 +105,7 @@
<% } %>
- <% if (section.returns) { %>
+ <% if (section.returns && section.returns.length) { %>
<% section.returns.forEach(function(ret) { %>
Returns
<%= formatType(ret.type) %><% if (ret.description) { %>:
@@ -112,7 +114,16 @@
<% }) %>
<% } %>
- <% if (section.throws) { %>
+ <% if (section.sees && section.sees.length) { %>
+
Related
+ <% section.sees.forEach(function(see) { %>
+ <% if (see.description) { %>
+ <%= md(see.description, true) %>
+ <% }%>
+ <% }) %>
+ <% } %>
+
+ <% if (section.throws && section.throws.length) { %>
Throws
<% section.throws.forEach(function(throws) { %>
@@ -121,7 +132,7 @@
<% } %>
- <% if (section.examples) { %>
+ <% if (section.examples && section.examples.length) { %>
Example
<% section.examples.forEach(function(example) { %>
<% if (example.caption) { %>
<%= md(example.caption) %>
<% } %>
@@ -131,16 +142,21 @@
<% if (section.members.static && section.members.static.length) { %>
Static Members
- <%= renderSectionList({ members: section.members.static, renderSection: renderSection, noun: 'Static Member' }) %>
+ <%= renderSectionList({ members: section.members.static, renderSection: renderSection, renderParamProperty: renderParamProperty, noun: 'Static Member' }) %>
<% } %>
<% if (section.members.instance && section.members.instance.length) { %>
Instance Members
- <%= renderSectionList({ members: section.members.instance, renderSection: renderSection, noun: 'Instance Member' }) %>
+ <%= renderSectionList({ members: section.members.instance, renderSection: renderSection, renderParamProperty: renderParamProperty, noun: 'Instance Member' }) %>
+ <% } %>
+
+ <% if (section.members.inner && section.members.inner.length) { %>
+
Inner Members
+ <%= renderSectionList({ members: section.members.inner, renderSection: renderSection, renderParamProperty: renderParamProperty, noun: 'Inner Member' }) %>
<% } %>
<% if (section.members.events && section.members.events.length) { %>
Events
- <%= renderSectionList({ members: section.members.events, renderSection: renderSection, noun: 'Event' }) %>
+ <%= renderSectionList({ members: section.members.events, renderSection: renderSection, renderParamProperty: renderParamProperty, noun: 'Event' }) %>
<% } %>
diff --git a/default_theme/section_list._ b/src/default_theme/section_list._
similarity index 79%
rename from default_theme/section_list._
rename to src/default_theme/section_list._
index 904483ccc..60d80ac32 100644
--- a/default_theme/section_list._
+++ b/src/default_theme/section_list._
@@ -1,6 +1,6 @@
<% members.forEach(function(member) { %>
-
+
▸
@@ -11,7 +11,8 @@
<%= renderSection({
section: member,
renderSection: renderSection,
- nested: true
+ renderParamProperty: renderParamProperty,
+ nested: true
}) %>
diff --git a/src/extractors/comments.js b/src/extractors/comments.js
new file mode 100644
index 000000000..2ab7dc884
--- /dev/null
+++ b/src/extractors/comments.js
@@ -0,0 +1,61 @@
+import babelTraverse from '@babel/traverse';
+import isJSDocComment from '../is_jsdoc_comment.js';
+
+const traverse = babelTraverse.default || babelTraverse;
+
+/**
+ * Iterate through the abstract syntax tree, finding a different kind of comment
+ * each time, and optionally including context. This is how we find
+ * JSDoc annotations that will become part of documentation
+ * @param type comment type to find
+ * @param includeContext to include context in the nodes
+ * @param ast the babel-parsed syntax tree
+ * @param data the filename and the source of the file the comment is in
+ * @param addComment a method that creates a new comment if necessary
+ * @returns comments
+ * @private
+ */
+export default function walkComments(
+ type,
+ includeContext,
+ ast,
+ data,
+ addComment
+) {
+ const newResults = [];
+
+ traverse(ast, {
+ /**
+ * Process a parse in an abstract syntax tree
+ * @param {Object} path ast path
+ * @returns {undefined} causes side effects
+ * @private
+ */
+ enter(path) {
+ /**
+ * Parse a comment with doctrine and decorate the result with file position and code context.
+ *
+ * @param {Object} comment the current state of the parsed JSDoc comment
+ * @returns {undefined} this emits data
+ */
+ function parseComment(comment) {
+ newResults.push(
+ addComment(
+ data,
+ comment.value,
+ comment.loc,
+ path,
+ path.node.loc,
+ includeContext
+ )
+ );
+ }
+
+ (path.node[type] || []).filter(isJSDocComment).forEach(parseComment);
+ }
+ });
+
+ traverse.cache.clear();
+
+ return newResults;
+}
diff --git a/src/extractors/exported.js b/src/extractors/exported.js
new file mode 100644
index 000000000..da6f8955b
--- /dev/null
+++ b/src/extractors/exported.js
@@ -0,0 +1,356 @@
+import babelTraverse from '@babel/traverse';
+import isJSDocComment from '../is_jsdoc_comment.js';
+import t from '@babel/types';
+import nodePath from 'path';
+import fs from 'fs';
+import { parseToAst } from '../parsers/parse_to_ast.js';
+import findTarget from '../infer/finders.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const traverse = babelTraverse.default || babelTraverse;
+
+/**
+ * Iterate through the abstract syntax tree, finding ES6-style exports,
+ * and inserting blank comments into documentation.js's processing stream.
+ * Through inference steps, these comments gain more information and are automatically
+ * documented as well as we can.
+ * @param {Object} config
+ * @param {Object} [config.extensions] extensions to try when resolving
+ * @param {Object} ast the babel-parsed syntax tree
+ * @param {Object} data the name of the file
+ * @param {Function} addComment a method that creates a new comment if necessary
+ * @returns {Array
} comments
+ * @private
+ */
+export default function walkExported(
+ config /* { extensions?: string[] } */,
+ ast,
+ data /*: {
+ file: string
+} */,
+ addComment
+) {
+ const newResults = [];
+ const filename = data.file;
+ const dataCache = new Map();
+
+ function addBlankComment(data, path, node) {
+ return addComment(data, '', node.loc, path, node.loc, true);
+ }
+
+ function getComments(data, path) {
+ const comments = (path.node.leadingComments || []).filter(isJSDocComment);
+
+ if (!comments.length) {
+ // If this is the first declarator we check for comments on the VariableDeclaration.
+ if (
+ t.isVariableDeclarator(path) &&
+ path.parentPath.get('declarations')[0] === path
+ ) {
+ return getComments(data, path.parentPath);
+ }
+
+ const added = addBlankComment(data, path, path.node);
+ return added ? [added] : [];
+ }
+
+ return comments
+ .map(function (comment) {
+ return addComment(
+ data,
+ comment.value,
+ comment.loc,
+ path,
+ path.node.loc,
+ true
+ );
+ })
+ .filter(Boolean);
+ }
+
+ function addComments(data, path, overrideName) {
+ const comments = getComments(data, path);
+ if (overrideName) {
+ comments.forEach(function (comment) {
+ comment.name = overrideName;
+ });
+ }
+ newResults.push.apply(newResults, comments);
+ }
+
+ traverse(ast, {
+ Statement(path) {
+ path.skip();
+ },
+ ExportDeclaration(path) {
+ const declaration = path.get('declaration');
+ if (t.isDeclaration(declaration)) {
+ traverseExportedSubtree(declaration, data, addComments);
+ return path.skip();
+ }
+
+ if (path.isExportDefaultDeclaration()) {
+ if (declaration.isIdentifier()) {
+ const binding = declaration.scope.getBinding(declaration.node.name);
+ traverseExportedSubtree(binding.path, data, addComments);
+ return path.skip();
+ }
+
+ traverseExportedSubtree(declaration, data, addComments);
+ return path.skip();
+ }
+
+ if (t.isExportNamedDeclaration(path)) {
+ const specifiers = path.get('specifiers');
+ const source = path.node.source;
+ const exportKind = path.node.exportKind;
+ specifiers.forEach(specifier => {
+ let specData = data;
+ let local;
+ if (t.isExportDefaultSpecifier(specifier)) {
+ local = 'default';
+ } else {
+ // ExportSpecifier
+ local = specifier.node.local.name;
+ }
+ const exported = specifier.node.exported.name;
+
+ let bindingPath;
+ if (source) {
+ const tmp = findExportDeclaration(
+ dataCache,
+ local,
+ exportKind,
+ filename,
+ source.value,
+ config.extensions
+ );
+ bindingPath = tmp.ast;
+ specData = tmp.data;
+ } else if (exportKind === 'value') {
+ bindingPath = path.scope.getBinding(local).path;
+ } else if (exportKind === 'type') {
+ bindingPath = findLocalType(path.scope, local);
+ } else {
+ throw new Error('Unreachable');
+ }
+
+ if (bindingPath === undefined) {
+ throw new Error(
+ `Unable to find the value ${exported} in ${specData.file}`
+ );
+ }
+ traverseExportedSubtree(bindingPath, specData, addComments, exported);
+ });
+ return path.skip();
+ }
+ }
+ });
+
+ return newResults;
+}
+
+function traverseExportedSubtree(path, data, addComments, overrideName) {
+ let attachCommentPath = path;
+ if (path.parentPath && path.parentPath.isExportDeclaration()) {
+ attachCommentPath = path.parentPath;
+ }
+ addComments(data, attachCommentPath, overrideName);
+
+ let target = findTarget(path);
+ if (!target) {
+ return;
+ }
+
+ if (t.isVariableDeclarator(target) && target.has('init')) {
+ target = target.get('init');
+ }
+
+ if (target.isClass() || target.isObjectExpression()) {
+ target.traverse({
+ Property(path) {
+ addComments(data, path);
+ path.skip();
+ },
+ Method(path) {
+ // Don't explicitly document constructor methods: their
+ // parameters are output as part of the class itself.
+ if (path.node.kind !== 'constructor') {
+ addComments(data, path);
+ }
+ path.skip();
+ }
+ });
+ }
+}
+
+function resolveFile(filePath, extensions = []) {
+ try {
+ // First try resolving the file with the default extensions.
+ return require.resolve(filePath);
+ } catch {
+ // If that fails, try resolving the file with the extensions passed in.
+ }
+
+ // Then try all other extensions in order.
+ for (const extension of extensions) {
+ try {
+ return require.resolve(
+ `${filePath}${extension.startsWith('.') ? extension : `.${extension}`}`
+ );
+ } catch {
+ continue;
+ }
+ }
+
+ throw new Error(
+ `Could not resolve \`${filePath}\` with any of the extensions: ${[
+ ...require.extensions,
+ ...extensions
+ ].join(', ')}`
+ );
+}
+
+function getCachedData(dataCache, filePath, extensions) {
+ const path = resolveFile(filePath, extensions);
+
+ let value = dataCache.get(path);
+ if (!value) {
+ const input = fs.readFileSync(path, 'utf-8');
+ const ast = parseToAst(input, path);
+ value = {
+ data: {
+ file: path,
+ source: input
+ },
+ ast
+ };
+ dataCache.set(path, value);
+ }
+ return value;
+}
+
+// Loads a module and finds the exported declaration.
+function findExportDeclaration(
+ dataCache,
+ name,
+ exportKind,
+ referrer,
+ filename,
+ extensions
+) {
+ const depPath = nodePath.resolve(nodePath.dirname(referrer), filename);
+ const tmp = getCachedData(dataCache, depPath, extensions);
+ const ast = tmp.ast;
+ let data = tmp.data;
+
+ let rv;
+ traverse(ast, {
+ Statement(path) {
+ path.skip();
+ },
+ ExportDeclaration(path) {
+ if (name === 'default' && path.isExportDefaultDeclaration()) {
+ rv = path.get('declaration');
+ path.stop();
+ } else if (path.isExportNamedDeclaration()) {
+ const declaration = path.get('declaration');
+ if (t.isDeclaration(declaration)) {
+ let bindingName;
+ if (
+ declaration.isFunctionDeclaration() ||
+ declaration.isClassDeclaration() ||
+ declaration.isTypeAlias() ||
+ declaration.isOpaqueType()
+ ) {
+ bindingName = declaration.node.id.name;
+ } else if (declaration.isVariableDeclaration()) {
+ // TODO: Multiple declarations.
+ bindingName = declaration.node.declarations[0].id.name;
+ }
+ if (name === bindingName) {
+ rv = declaration;
+ path.stop();
+ } else {
+ path.skip();
+ }
+ return;
+ }
+
+ // export {x as y}
+ // export {x as y} from './file.js'
+ const specifiers = path.get('specifiers');
+ const source = path.node.source;
+ for (let i = 0; i < specifiers.length; i++) {
+ const specifier = specifiers[i];
+ let local, exported;
+ if (t.isExportDefaultSpecifier(specifier)) {
+ // export x from ...
+ local = 'default';
+ exported = specifier.node.exported.name;
+ } else {
+ // ExportSpecifier
+ local = specifier.node.local.name;
+ exported = specifier.node.exported.name;
+ }
+ if (exported === name) {
+ if (source) {
+ // export {local as exported} from './file.js';
+ const tmp = findExportDeclaration(
+ dataCache,
+ local,
+ exportKind,
+ depPath,
+ source.value,
+ extensions
+ );
+ rv = tmp.ast;
+ data = tmp.data;
+ if (!rv) {
+ throw new Error(`${name} is not exported by ${depPath}`);
+ }
+ } else {
+ // export {local as exported}
+ if (exportKind === 'value') {
+ rv = path.scope.getBinding(local).path;
+ } else {
+ rv = findLocalType(path.scope, local);
+ }
+ if (!rv) {
+ throw new Error(`${depPath} has no binding for ${name}`);
+ }
+ }
+ path.stop();
+ return;
+ }
+ }
+ }
+ }
+ });
+
+ return {
+ ast: rv,
+ data
+ };
+}
+
+// Since we cannot use scope.getBinding for types this walks the current scope looking for a
+// top-level type alias.
+function findLocalType(scope, local) {
+ let rv;
+ scope.path.traverse({
+ Statement(path) {
+ path.skip();
+ },
+ TypeAlias(path) {
+ if (path.node.id.name === local) {
+ rv = path;
+ path.stop();
+ } else {
+ path.skip();
+ }
+ }
+ });
+ return rv;
+}
diff --git a/lib/filter_access.js b/src/filter_access.js
similarity index 70%
rename from lib/filter_access.js
rename to src/filter_access.js
index d32564b64..610aa3fa5 100644
--- a/lib/filter_access.js
+++ b/src/filter_access.js
@@ -1,6 +1,4 @@
-'use strict';
-
-var walk = require('./walk');
+import walk from './walk.js';
/**
* Exclude given access levels from the generated documentation: this allows
@@ -9,18 +7,18 @@ var walk = require('./walk');
*
* @param {Array} [levels=['public', 'undefined', 'protected']] included access levels.
* @param {Array} comments parsed comments (can be nested)
- * @return {Array} filtered comments
+ * @returns {Array} filtered comments
*/
function filterAccess(levels, comments) {
- levels = levels || ['public', 'undefined', 'protected'];
-
function filter(comment) {
- return comment.kind === 'note' ||
- (!comment.ignore && levels.indexOf(String(comment.access)) !== -1);
+ return (
+ comment.kind === 'note' ||
+ (!comment.ignore && levels.indexOf(String(comment.access)) !== -1)
+ );
}
function recurse(comment) {
- for (var scope in comment.members) {
+ for (const scope in comment.members) {
comment.members[scope] = comment.members[scope].filter(filter);
}
}
@@ -28,4 +26,4 @@ function filterAccess(levels, comments) {
return walk(comments.filter(filter), recurse);
}
-module.exports = filterAccess;
+export default filterAccess;
diff --git a/src/flow_doctrine.js b/src/flow_doctrine.js
new file mode 100644
index 000000000..f81f2ffc8
--- /dev/null
+++ b/src/flow_doctrine.js
@@ -0,0 +1,169 @@
+import generator from '@babel/generator';
+const generate = generator.default || generator;
+
+const namedTypes = {
+ NumberTypeAnnotation: 'number',
+ BooleanTypeAnnotation: 'boolean',
+ StringTypeAnnotation: 'string',
+ SymbolTypeAnnotation: 'symbol'
+};
+
+const oneToOne = {
+ AnyTypeAnnotation: 'AllLiteral',
+ MixedTypeAnnotation: 'AllLiteral',
+ NullLiteralTypeAnnotation: 'NullLiteral',
+ VoidTypeAnnotation: 'VoidLiteral'
+};
+
+function propertyToField(property) {
+ if (!property.value) return null;
+
+ let type = flowDoctrine(property.value);
+ if (property.optional) {
+ // Doctrine does not support optional fields but it does have something called optional types
+ // (which makes no sense, but let's play along).
+ type = {
+ type: 'OptionalType',
+ expression: type
+ };
+ }
+ return {
+ type: 'FieldType',
+ key: property.key.name || property.key.value,
+ value: type
+ };
+}
+
+/**
+ * Babel parses Flow annotations in JavaScript into AST nodes. documentation.js uses
+ * Babel to parse JavaScript. This method restructures those Babel-generated
+ * objects into objects that fit the output of Doctrine, the module we use
+ * to parse JSDoc annotations. This lets us use Flow annotations _as_
+ * JSDoc annotations.
+ *
+ * @private
+ * @param {Object} type babel-parsed flow type
+ * @returns {Object} doctrine compatible type
+ */
+function flowDoctrine(type) {
+ if (type.type in namedTypes) {
+ const doctrineType = {
+ type: 'NameExpression',
+ name: namedTypes[type.type]
+ };
+ return doctrineType;
+ }
+
+ if (type.type in oneToOne) {
+ return { type: oneToOne[type.type] };
+ }
+
+ switch (type.type) {
+ case 'NullableTypeAnnotation':
+ return {
+ type: 'NullableType',
+ expression: flowDoctrine(type.typeAnnotation)
+ };
+ case 'UnionTypeAnnotation':
+ return {
+ type: 'UnionType',
+ elements: type.types.map(flowDoctrine)
+ };
+ // [number]
+ // [string, boolean, number]
+ case 'TupleTypeAnnotation':
+ return {
+ type: 'ArrayType',
+ elements: type.types.map(flowDoctrine)
+ };
+ // number[]
+ case 'ArrayTypeAnnotation':
+ return {
+ type: 'TypeApplication',
+ expression: {
+ type: 'NameExpression',
+ name: 'Array'
+ },
+ applications: [flowDoctrine(type.elementType)]
+ };
+ // (y: number) => bool
+ case 'FunctionTypeAnnotation':
+ return {
+ type: 'FunctionType',
+ params: type.params.map(param => {
+ let name = '';
+ if (param.name && param.name.name) {
+ name = param.name.name;
+ }
+ return {
+ type: 'ParameterType',
+ name,
+ expression: flowDoctrine(param.typeAnnotation)
+ };
+ }),
+ result: flowDoctrine(type.returnType)
+ };
+
+ case 'GenericTypeAnnotation':
+ if (type.typeParameters) {
+ return {
+ type: 'TypeApplication',
+ expression: {
+ type: 'NameExpression',
+ name: generate(type.id, {
+ compact: true
+ }).code
+ },
+ applications: type.typeParameters.params.map(flowDoctrine)
+ };
+ }
+
+ return {
+ type: 'NameExpression',
+ name: generate(type.id, {
+ compact: true
+ }).code
+ };
+
+ case 'ObjectTypeAnnotation':
+ if (type.properties) {
+ return {
+ type: 'RecordType',
+ fields: type.properties.map(propertyToField).filter(x => x)
+ };
+ }
+
+ return {
+ type: 'NameExpression',
+ name: generate(type.id, {
+ compact: true
+ }).code
+ };
+ case 'BooleanLiteralTypeAnnotation':
+ return {
+ type: 'BooleanLiteralType',
+ value: type.value
+ };
+ case 'NumberLiteralTypeAnnotation':
+ return {
+ type: 'NumericLiteralType',
+ value: type.value
+ };
+ case 'StringLiteralTypeAnnotation':
+ return {
+ type: 'StringLiteralType',
+ value: type.value
+ };
+ case 'ThisTypeAnnotation':
+ return {
+ type: 'NameExpression',
+ name: 'this'
+ };
+ default:
+ return {
+ type: 'AllLiteral'
+ };
+ }
+}
+
+export default flowDoctrine;
diff --git a/lib/garbage_collect.js b/src/garbage_collect.js
similarity index 78%
rename from lib/garbage_collect.js
rename to src/garbage_collect.js
index 79b8ed36b..47ed77aa1 100644
--- a/lib/garbage_collect.js
+++ b/src/garbage_collect.js
@@ -4,4 +4,4 @@ function garbageCollect(comment) {
return comment;
}
-module.exports = garbageCollect;
+export default garbageCollect;
diff --git a/src/get-readme-file.js b/src/get-readme-file.js
new file mode 100644
index 000000000..74fc63480
--- /dev/null
+++ b/src/get-readme-file.js
@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+
+export default function findReadme(dir) {
+ const readmeFilenames = [
+ 'README.markdown',
+ 'README.md',
+ 'Readme.md',
+ 'readme.markdown',
+ 'readme.md'
+ ];
+
+ const readmeFile = fs.readdirSync(dir).find(function (filename) {
+ return readmeFilenames.indexOf(filename) >= 0;
+ });
+
+ if (readmeFile) {
+ return path.join(fs.realpathSync(dir), readmeFile);
+ }
+
+ return 'README.md';
+}
diff --git a/src/git/find_git.js b/src/git/find_git.js
new file mode 100644
index 000000000..39869c007
--- /dev/null
+++ b/src/git/find_git.js
@@ -0,0 +1,27 @@
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Given a full path to a single file, iterate upwards through the filesystem
+ * to find a directory with a .git file indicating that it is a git repository
+ * @param filename any file within a repository
+ * @returns repository root & its .git folder paths
+ */
+export default function findGit(filename) {
+ let root = path.resolve(filename);
+ while (root) {
+ root = path.dirname(root);
+ let git = path.join(root, '.git');
+ if (!fs.existsSync(git)) continue;
+
+ if (fs.statSync(git).isFile()) {
+ // git submodule
+ const matches = fs.readFileSync(git, 'utf8').match(/gitdir: (.*)/);
+ if (!matches) return null;
+ git = path.join(root, matches[1]);
+ }
+
+ return { root, git };
+ }
+ return null;
+}
diff --git a/src/git/url_prefix.js b/src/git/url_prefix.js
new file mode 100644
index 000000000..235b4ca80
--- /dev/null
+++ b/src/git/url_prefix.js
@@ -0,0 +1,85 @@
+import fs from 'fs';
+import path from 'path';
+import gitUrlParse from 'git-url-parse';
+import ini from 'ini';
+
+/**
+ * Sometimes git will [pack refs](https://git-scm.com/docs/git-pack-refs)
+ * in order to save space on disk and
+ * duck under limits of numbers of files in folders. CircleCI in particular
+ * does this by default. This method parses that `packed-refs` file
+ *
+ * @private
+ * @param {string} packedRefs string contents of the packed refs file
+ * @param {string} branchName the branch name to resolve to
+ * @returns {string} sha hash referring to current tree
+ */
+export function parsePackedRefs(packedRefs, branchName) {
+ return packedRefs
+ .split(/\n/)
+ .filter(line => line[0] !== '#' && line[0] !== '^')
+ .reduce((memo, line) => {
+ memo[line.split(' ')[1]] = line.split(' ')[0];
+ return memo;
+ }, {})[branchName];
+}
+
+/**
+ * Given a a root directory, find its git configuration and figure out
+ * the HTTPS URL at the base of that GitHub repository.
+ *
+ * @param {string} root path at the base of this local repo
+ * @returns {string} base HTTPS url of the GitHub repository
+ * @throws {Error} if the root is not a git repo
+ */
+export function getGithubURLPrefix({ git, root }) {
+ let sha;
+ try {
+ const head = fs.readFileSync(path.join(git, 'HEAD'), 'utf8');
+ const branch = head.match(/ref: (.*)/);
+ if (branch) {
+ const branchName = branch[1];
+ const branchFileName = path.join(git, branchName);
+ const packedRefsName = path.join(git, 'packed-refs');
+ if (fs.existsSync(branchFileName)) {
+ sha = fs.readFileSync(branchFileName, 'utf8');
+ } else if (fs.existsSync(packedRefsName)) {
+ // packed refs are a compacted version of the refs folder. usually
+ // you have a folder filled with files that just contain sha
+ // hashes. since this folder can be really big, packed refs
+ // stores all the refs in one file instead.
+ sha = parsePackedRefs(
+ fs.readFileSync(packedRefsName, 'utf8'),
+ branchName
+ );
+ }
+ } else {
+ sha = head;
+ }
+ if (sha) {
+ let origin;
+ if (git.indexOf(root) === 0) {
+ const config = parseGitConfig(path.join(git, 'config'));
+ origin = config['remote "origin"'].url;
+ } else {
+ const config = parseGitConfig(path.join(git, '..', '..', 'config'));
+ origin = config[`submodule "${path.basename(git)}"`].url;
+ }
+ const parsed = gitUrlParse(origin);
+ parsed.git_suffix = false; // eslint-disable-line
+ return parsed.toString('https') + '/blob/' + sha.trim() + '/';
+ }
+ } catch (e) {
+ return null;
+ }
+}
+
+function parseGitConfig(configPath) {
+ const str = fs
+ .readFileSync(configPath, 'utf8')
+ .replace(
+ /\[(\S+) "(.+)"\]/g,
+ (match, key, value) => `[${key} "${value.split('.').join('\\.')}"]`
+ );
+ return ini.parse(str);
+}
diff --git a/src/github.js b/src/github.js
new file mode 100644
index 000000000..d52a8afdc
--- /dev/null
+++ b/src/github.js
@@ -0,0 +1,41 @@
+import path from 'path';
+import findGit from './git/find_git.js';
+import { getGithubURLPrefix } from './git/url_prefix.js';
+
+/**
+ * Attempts to link code to its place on GitHub.
+ *
+ * @name linkGitHub
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with github inferred
+ */
+export default function (comment) {
+ const paths = findGit(comment.context.file);
+
+ const urlPrefix = paths && getGithubURLPrefix(paths);
+
+ if (urlPrefix) {
+ const fileRelativePath = comment.context.file
+ .replace(paths.root + path.sep, '')
+ .split(path.sep)
+ .join('/');
+
+ let startLine;
+ let endLine;
+
+ if (comment.kind == 'typedef') {
+ startLine = comment.loc.start.line;
+ endLine = comment.loc.end.line;
+ } else {
+ startLine = comment.context.loc.start.line;
+ endLine = comment.context.loc.end.line;
+ }
+
+ comment.context.github = {
+ url:
+ urlPrefix + fileRelativePath + '#L' + startLine + '-' + 'L' + endLine,
+ path: fileRelativePath
+ };
+ }
+ return comment;
+}
diff --git a/src/hierarchy.js b/src/hierarchy.js
new file mode 100644
index 000000000..7bb870cbe
--- /dev/null
+++ b/src/hierarchy.js
@@ -0,0 +1,247 @@
+import _ from 'lodash';
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * Check if a given member object is of kind `event`.
+ * @param {Object} member - The member to check.
+ * @returns {boolean} `true` if it is of kind `event`, otherwise false.
+ */
+const isEvent = member => member.kind === 'event';
+
+/**
+ * We need to have members of all valid JSDoc scopes.
+ * @private
+ */
+const getMembers = () => ({
+ global: Object.create(null),
+ inner: Object.create(null),
+ instance: Object.create(null),
+ events: Object.create(null),
+ static: Object.create(null)
+});
+
+/**
+ * Pick only relevant properties from a comment to store them in
+ * an inheritance chain
+ * @param comment a parsed comment
+ * @returns reduced comment
+ * @private
+ */
+function pick(comment) {
+ if (typeof comment.name !== 'string') {
+ return undefined;
+ }
+
+ const item = {
+ name: comment.name,
+ kind: comment.kind
+ };
+
+ if (comment.scope) {
+ item.scope = comment.scope;
+ }
+
+ return item;
+}
+
+/**
+ * @param {Array} comments an array of parsed comments
+ * @returns {Array} nested comments, with only root comments
+ * at the top level.
+ */
+export default function (comments) {
+ let id = 0;
+ const root = {
+ members: getMembers()
+ };
+
+ const namesToUnroot = [];
+
+ comments.forEach(comment => {
+ let path = comment.path;
+ if (!path) {
+ path = [];
+
+ if (comment.memberof) {
+ // TODO: full namepath parsing
+ path = comment.memberof
+ .split('.')
+ .map(segment => ({ scope: 'static', name: segment }));
+ }
+
+ if (!comment.name) {
+ comment.errors.push({
+ message: 'could not determine @name for hierarchy'
+ });
+ }
+
+ path.push({
+ scope: comment.scope || 'static',
+ name: comment.name || 'unknown_' + id++
+ });
+ }
+
+ let node = root;
+
+ while (path.length) {
+ const segment = path.shift();
+ const scope = segment.scope;
+ const name = segment.name;
+
+ if (!hasOwnProperty.call(node.members[scope], name)) {
+ // If segment.toc is true, everything up to this point in the path
+ // represents how the documentation should be nested, but not how the
+ // actual code is nested. To ensure that child members end up in the
+ // right places in the tree, we temporarily push the same node a second
+ // time to the root of the tree, and unroot it after all the comments
+ // have found their homes.
+ if (
+ segment.toc &&
+ node !== root &&
+ hasOwnProperty.call(root.members[scope], name)
+ ) {
+ node.members[scope][name] = root.members[scope][name];
+ namesToUnroot.push(name);
+ } else {
+ const newNode = (node.members[scope][name] = {
+ comments: [],
+ members: getMembers()
+ });
+ if (segment.toc && node !== root) {
+ root.members[scope][name] = newNode;
+ namesToUnroot.push(name);
+ }
+ }
+ }
+
+ node = node.members[scope][name];
+ }
+
+ node.comments.push(comment);
+ });
+ namesToUnroot.forEach(function (name) {
+ delete root.members.static[name];
+ });
+
+ /*
+ * Massage the hierarchy into a format more suitable for downstream consumers:
+ *
+ * * Individual top-level scopes are collapsed to a single array
+ * * Members at intermediate nodes are copied over to the corresponding comments,
+ * with multisignature comments allowed.
+ * * Intermediate nodes without corresponding comments indicate an undefined
+ * @memberof reference. Emit an error, and reparent the offending comment to
+ * the root.
+ * * Add paths to each comment, making it possible to generate permalinks
+ * that differentiate between instance functions with the same name but
+ * different `@memberof` values.
+ *
+ * Person#say // the instance method named "say."
+ * Person.say // the static method named "say."
+ * Person~say // the inner method named "say."
+ */
+ function toComments(nodes, root, hasUndefinedParent, path) {
+ const result = [];
+ let scope;
+
+ path = path || [];
+
+ for (const name in nodes) {
+ const node = nodes[name];
+
+ for (scope in node.members) {
+ node.members[scope] = toComments(
+ node.members[scope],
+ root || result,
+ !node.comments.length,
+ node.comments.length && node.comments[0].kind !== 'note'
+ ? path.concat(node.comments[0])
+ : []
+ );
+ }
+
+ for (let i = 0; i < node.comments.length; i++) {
+ const comment = node.comments[i];
+
+ comment.members = {};
+ for (scope in node.members) {
+ comment.members[scope] = node.members[scope];
+ }
+
+ let events = comment.members.events;
+ let groups = [];
+
+ if (comment.members.instance.length) {
+ groups = _.groupBy(comment.members.instance, isEvent);
+
+ events = events.concat(groups[true] || []);
+ comment.members.instance = groups[false] || [];
+ }
+
+ if (comment.members.static.length) {
+ groups = _.groupBy(comment.members.static, isEvent);
+
+ events = events.concat(groups[true] || []);
+ comment.members.static = groups[false] || [];
+ }
+
+ if (comment.members.inner.length) {
+ groups = _.groupBy(comment.members.inner, isEvent);
+
+ events = events.concat(groups[true] || []);
+ comment.members.inner = groups[false] || [];
+ }
+
+ if (comment.members.global.length) {
+ groups = _.groupBy(comment.members.global, isEvent);
+
+ events = events.concat(groups[true] || []);
+ comment.members.global = groups[false] || [];
+ }
+
+ comment.members.events = events;
+
+ comment.path = path.map(pick).concat(pick(comment)).filter(Boolean);
+
+ const scopeChars = {
+ instance: '#',
+ static: '.',
+ inner: '~',
+ global: ''
+ };
+
+ comment.namespace = comment.path.reduce((memo, part) => {
+ if (part.kind === 'event') {
+ return memo + '.event:' + part.name;
+ }
+ let scopeChar = '';
+ if (part.scope) {
+ scopeChar = scopeChars[part.scope];
+ }
+ return memo + scopeChar + part.name;
+ }, '');
+
+ if (hasUndefinedParent) {
+ const memberOfTag = comment.tags.filter(
+ tag => tag.title === 'memberof'
+ )[0];
+ const memberOfTagLineNumber =
+ (memberOfTag && memberOfTag.lineNumber) || 0;
+
+ comment.errors.push({
+ message: `@memberof reference to ${comment.memberof} not found`,
+ commentLineNumber: memberOfTagLineNumber
+ });
+
+ root.push(comment);
+ } else {
+ result.push(comment);
+ }
+ }
+ }
+
+ return result;
+ }
+
+ return toComments(root.members.static);
+}
diff --git a/src/index.js b/src/index.js
new file mode 100644
index 000000000..abe624c7c
--- /dev/null
+++ b/src/index.js
@@ -0,0 +1,233 @@
+import _ from 'lodash';
+import sort from './sort.js';
+import { nest } from './nest.js';
+import filterAccess from './filter_access.js';
+import dependency from './input/dependency.js';
+import shallow from './input/shallow.js';
+import parseJavaScript from './parsers/javascript.js';
+import github from './github.js';
+import hierarchy from './hierarchy.js';
+import inferName from './infer/name.js';
+import inferKind from './infer/kind.js';
+import inferAugments from './infer/augments.js';
+import inferImplements from './infer/implements.js';
+import inferParams from './infer/params.js';
+import inferProperties from './infer/properties.js';
+import inferMembership from './infer/membership.js';
+import inferReturn from './infer/return.js';
+import inferAccess from './infer/access.js';
+import inferType from './infer/type.js';
+import { formatLint, lintComments } from './lint.js';
+import garbageCollect from './garbage_collect.js';
+import markdownAST from './output/markdown_ast.js';
+import mergeConfig from './merge_config.js';
+import html from './output/html.js';
+import md from './output/markdown.js';
+import json from './output/json.js';
+import createFormatters from './output/util/formatters.js';
+import LinkerStack from './output/util/linker_stack.js';
+
+/**
+ * Build a pipeline of comment handlers.
+ * @param {Array} fns - Pipeline elements. Each is a function that accepts
+ * a comment and can return a comment or undefined (to drop that comment).
+ * @returns {Function} pipeline
+ * @private
+ */
+function pipeline(fns) {
+ return comment => {
+ for (let i = 0; comment && i < fns.length; i++) {
+ if (fns[i]) {
+ comment = fns[i](comment);
+ }
+ }
+ return comment;
+ };
+}
+
+function configure(indexes, args) {
+ const mergedConfig = mergeConfig(args);
+
+ return mergedConfig.then(config => {
+ const expandedInputs = expandInputs(indexes, config);
+
+ return expandedInputs.then(inputs => {
+ return {
+ inputs,
+ config
+ };
+ });
+ });
+}
+
+/**
+ * Given an array of indexes and options for whether to resolve shallow
+ * or deep dependencies, resolve dependencies.
+ *
+ * @param {Array|string} indexes files to process
+ * @param {Object} config options
+ * @returns {Promise>} promise with results
+ */
+export function expandInputs(indexes, config) {
+ // Ensure that indexes is an array of strings
+ indexes = [].concat(indexes);
+
+ if (config.shallow || config.documentExported) {
+ return shallow(indexes, config);
+ }
+
+ return dependency(indexes, config);
+}
+
+function buildInternal(inputsAndConfig) {
+ const config = inputsAndConfig.config;
+ const inputs = inputsAndConfig.inputs;
+
+ if (!config.access) {
+ config.access = ['public', 'undefined', 'protected'];
+ }
+
+ const buildPipeline = pipeline([
+ inferName,
+ inferAccess(config.inferPrivate),
+ inferAugments,
+ inferImplements,
+ inferKind,
+ nest,
+ inferParams,
+ inferProperties,
+ inferReturn,
+ inferMembership(),
+ inferType,
+ config.github && github,
+ garbageCollect
+ ]);
+
+ const extractedComments = _.flatMap(inputs, function (sourceFile) {
+ return parseJavaScript(sourceFile, config).map(buildPipeline);
+ }).filter(Boolean);
+
+ return filterAccess(
+ config.access,
+ hierarchy(sort(extractedComments, config))
+ );
+}
+
+function lintInternal(inputsAndConfig) {
+ const inputs = inputsAndConfig.inputs;
+ const config = inputsAndConfig.config;
+
+ const lintPipeline = pipeline([
+ lintComments,
+ inferName,
+ inferAccess(config.inferPrivate),
+ inferAugments,
+ inferKind,
+ inferParams,
+ inferProperties,
+ inferReturn,
+ inferMembership(),
+ inferType,
+ nest
+ ]);
+
+ const extractedComments = _.flatMap(inputs, sourceFile => {
+ return parseJavaScript(sourceFile, config).map(lintPipeline);
+ }).filter(Boolean);
+
+ return formatLint(hierarchy(extractedComments));
+}
+
+/**
+ * Lint files for non-standard or incorrect documentation
+ * information, returning a potentially-empty string
+ * of lint information intended for human-readable output.
+ *
+ * @param {Array|string} indexes files to process
+ * @param {Object} args args
+ * @param {Array} args.external a string regex / glob match pattern
+ * that defines what external modules will be whitelisted and included in the
+ * generated documentation.
+ * @param {boolean} [args.shallow=false] whether to avoid dependency parsing
+ * even in JavaScript code.
+ * @param {string} [args.inferPrivate] a valid regular expression string
+ * to infer whether a code element should be private, given its naming structure.
+ * For instance, you can specify `inferPrivate: '^_'` to automatically treat
+ * methods named like `_myMethod` as private.
+ * @param {string|Array} [args.extension] treat additional file extensions
+ * as JavaScript, extending the default set of `js`, `es6`, and `jsx`.
+ * @returns {Promise} promise with lint results
+ * @public
+ * @example
+ * documentation.lint('file.js').then(lintOutput => {
+ * if (lintOutput) {
+ * console.log(lintOutput);
+ * process.exit(1);
+ * } else {
+ * process.exit(0);
+ * }
+ * });
+ */
+export const lint = (indexes, args) =>
+ configure(indexes, args).then(lintInternal);
+
+/**
+ * Generate JavaScript documentation as a list of parsed JSDoc
+ * comments, given a root file as a path.
+ *
+ * @param {Array|string} indexes files to process
+ * @param {Object} args args
+ * @param {Array} args.external a string regex / glob match pattern
+ * that defines what external modules will be whitelisted and included in the
+ * generated documentation.
+ * @param {boolean} [args.shallow=false] whether to avoid dependency parsing
+ * even in JavaScript code.
+ * @param {Array} [args.order=[]] optional array that
+ * defines sorting order of documentation
+ * @param {Array} [args.access=[]] an array of access levels
+ * to output in documentation
+ * @param {Object} [args.hljs] hljs optional args
+ * @param {boolean} [args.hljs.highlightAuto=false] hljs automatically detect language
+ * @param {Array} [args.hljs.languages] languages for hljs to choose from
+ * @param {string} [args.inferPrivate] a valid regular expression string
+ * to infer whether a code element should be private, given its naming structure.
+ * For instance, you can specify `inferPrivate: '^_'` to automatically treat
+ * methods named like `_myMethod` as private.
+ * @param {string|Array} [args.extension] treat additional file extensions
+ * as JavaScript, extending the default set of `js`, `es6`, and `jsx`.
+ * @returns {Promise} results
+ * @public
+ * @example
+ * var documentation = require('documentation');
+ *
+ * documentation.build(['index.js'], {
+ * // only output comments with an explicit @public tag
+ * access: ['public']
+ * }).then(res => {
+ * // res is an array of parsed comments with inferred properties
+ * // and more: everything you need to build documentation or
+ * // any other kind of code data.
+ * });
+ */
+export const build = (indexes, args) =>
+ configure(indexes, args).then(buildInternal);
+
+/**
+ * Documentation's formats are modular methods that take comments
+ * and config as input and return Promises with results,
+ * like stringified JSON, markdown strings, or Vinyl objects for HTML
+ * output.
+ * @public
+ */
+export const formats = {
+ html,
+ md,
+ remark: (comments, config) =>
+ markdownAST(comments, config).then(res => JSON.stringify(res, null, 2)),
+ json
+};
+
+export const util = {
+ createFormatters,
+ LinkerStack
+};
diff --git a/src/infer/access.js b/src/infer/access.js
new file mode 100644
index 000000000..32f304f54
--- /dev/null
+++ b/src/infer/access.js
@@ -0,0 +1,43 @@
+/**
+ * Given a string with a pattern that might infer access level, like `^_`,
+ * create an inference method.
+ *
+ * @param {?string} pattern regexp-compatible pattern
+ * @returns {Function} inference method
+ * @private
+ */
+export default function inferAccessWithPattern(pattern) {
+ const re = pattern && new RegExp(pattern);
+
+ /**
+ * Infers access from TypeScript annotations, and from the name (only private atm).
+ *
+ * @name inferAccess
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with access inferred
+ */
+ return function inferAccess(comment) {
+ // Support typescript access modifiers
+ const ast = comment.context.ast;
+ if (ast && ast.node.accessibility) {
+ comment.access = ast.node.accessibility;
+ }
+
+ if (ast && ast.node.readonly) {
+ comment.readonly = true;
+ }
+
+ // This needs to run after inferName because we infer the access based on
+ // the name.
+ if (
+ re &&
+ comment.name &&
+ comment.access === undefined &&
+ re.test(comment.name)
+ ) {
+ comment.access = 'private';
+ }
+
+ return comment;
+ };
+}
diff --git a/src/infer/augments.js b/src/infer/augments.js
new file mode 100644
index 000000000..f310c167b
--- /dev/null
+++ b/src/infer/augments.js
@@ -0,0 +1,55 @@
+import babelGenerate from '@babel/generator';
+import findTarget from './finders.js';
+
+const generate = babelGenerate.default || babelGenerate;
+
+/**
+ * Infers an `augments` tag from an ES6 class declaration
+ *
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with kind inferred
+ */
+export default function inferAugments(comment) {
+ if (comment.augments.length) {
+ return comment;
+ }
+
+ const path = findTarget(comment.context.ast);
+
+ if (!path) {
+ return comment;
+ }
+
+ if (path.isClass()) {
+ /*
+ * A superclass can be a single name, like React,
+ * or a MemberExpression like React.Component,
+ * so we generate code from the AST rather than assuming
+ * we can access a name like `path.node.superClass.name`
+ */
+ if (path.node.superClass) {
+ comment.augments.push({
+ title: 'augments',
+ name: generate(path.node.superClass).code
+ });
+ }
+ } else if (
+ (path.isInterfaceDeclaration() || path.isTSInterfaceDeclaration()) &&
+ path.node.extends
+ ) {
+ /*
+ * extends is an array of interface identifiers or
+ * qualified type identifiers, so we generate code
+ * from the AST rather than assuming we can acces
+ * a name.
+ */
+ path.node.extends.forEach(node => {
+ comment.augments.push({
+ title: 'extends',
+ name: generate(node).code
+ });
+ });
+ }
+
+ return comment;
+}
diff --git a/src/infer/finders.js b/src/infer/finders.js
new file mode 100644
index 000000000..2592e3bb8
--- /dev/null
+++ b/src/infer/finders.js
@@ -0,0 +1,38 @@
+import t from '@babel/types';
+
+/**
+ * Try to find the part of JavaScript a comment is referring to, by
+ * looking at the syntax tree closest to that comment.
+ *
+ * @param {Object} path abstract syntax tree path
+ * @returns {?Object} ast path, if one is found.
+ * @private
+ */
+export default function findTarget(path) {
+ if (!path) {
+ return path;
+ }
+
+ if (
+ t.isExportDefaultDeclaration(path) ||
+ (t.isExportNamedDeclaration(path) && path.has('declaration'))
+ ) {
+ path = path.get('declaration');
+ }
+
+ if (t.isVariableDeclaration(path)) {
+ // var x = init;
+ path = path.get('declarations')[0];
+ } else if (t.isExpressionStatement(path)) {
+ // foo.x = TARGET
+ path = path.get('expression').get('right');
+ } else if (t.isObjectProperty(path) || t.isObjectTypeProperty(path)) {
+ // var foo = { x: TARGET }; object property
+ path = path.get('value');
+ } else if (t.isClassProperty(path) && path.get('value').node) {
+ // var foo = { x = TARGET }; class property
+ path = path.get('value');
+ }
+
+ return path.node && path;
+}
diff --git a/src/infer/implements.js b/src/infer/implements.js
new file mode 100644
index 000000000..26240898e
--- /dev/null
+++ b/src/infer/implements.js
@@ -0,0 +1,38 @@
+import babelGenerate from '@babel/generator';
+import findTarget from './finders.js';
+
+const generate = babelGenerate.default || babelGenerate;
+
+/**
+ * Infers an `augments` tag from an ES6 class declaration
+ *
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with kind inferred
+ */
+export default function inferImplements(comment) {
+ if (comment.implements.length) {
+ return comment;
+ }
+
+ const path = findTarget(comment.context.ast);
+ if (!path) {
+ return comment;
+ }
+
+ if (path.isClass() && path.node.implements) {
+ /*
+ * A interface can be a single name, like React,
+ * or a MemberExpression like React.Component,
+ * so we generate code from the AST rather than assuming
+ * we can access a name like `path.node.implements.name`
+ */
+ path.node.implements.forEach(impl => {
+ comment.implements.push({
+ title: 'implements',
+ name: generate(impl).code
+ });
+ });
+ }
+
+ return comment;
+}
diff --git a/src/infer/kind.js b/src/infer/kind.js
new file mode 100644
index 000000000..f6ecdd4aa
--- /dev/null
+++ b/src/infer/kind.js
@@ -0,0 +1,98 @@
+import t from '@babel/types';
+
+/**
+ * Infers a `kind` tag from the context.
+ *
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with kind inferred
+ */
+export default function inferKind(comment) {
+ if (comment.kind) {
+ return comment;
+ }
+
+ function findKind(node) {
+ if (!node) {
+ return comment;
+ }
+
+ if (t.isClassDeclaration(node)) {
+ comment.kind = 'class';
+ if (node.abstract) {
+ comment.abstract = true;
+ }
+ } else if (
+ t.isFunction(node) ||
+ t.isTSDeclareMethod(node) ||
+ t.isTSDeclareFunction(node) ||
+ t.isFunctionTypeAnnotation(node) ||
+ t.isTSMethodSignature(node)
+ ) {
+ if (node.kind === 'get' || node.kind === 'set') {
+ comment.kind = 'member';
+ } else if (node.id && node.id.name && !!/^[A-Z]/.exec(node.id.name)) {
+ comment.kind = 'class';
+ } else {
+ comment.kind = 'function';
+ if (node.async) {
+ comment.async = true;
+ }
+ if (node.generator) {
+ comment.generator = true;
+ }
+ if (node.abstract) {
+ comment.abstract = true;
+ }
+ }
+ } else if (t.isTypeAlias(node) || t.isTSTypeAliasDeclaration(node)) {
+ comment.kind = 'typedef';
+ } else if (
+ t.isInterfaceDeclaration(node) ||
+ t.isTSInterfaceDeclaration(node)
+ ) {
+ comment.kind = 'interface';
+ } else if (t.isVariableDeclaration(node)) {
+ if (node.kind === 'const') {
+ comment.kind = 'constant';
+ } else {
+ // This behavior is in need of fixing https://github.com/documentationjs/documentation/issues/351
+ findKind(node.declarations[0].init);
+ }
+ } else if (t.isExportDeclaration(node)) {
+ // export var x = ...
+ // export function f() {}
+ // export class C {}
+ // export default function f() {}
+ // export default class C {}
+ findKind(node.declaration);
+ } else if (t.isExpressionStatement(node)) {
+ // module.exports = function() {}
+ findKind(node.expression.right);
+ } else if (
+ t.isClassProperty(node) ||
+ t.isTSPropertySignature(node) ||
+ t.isTSEnumMember(node)
+ ) {
+ comment.kind = 'member';
+ } else if (t.isProperty(node)) {
+ // { foo: function() {} }
+ findKind(node.value);
+ } else if (t.isTSModuleDeclaration(node)) {
+ comment.kind = 'namespace';
+ } else if (t.isObjectTypeProperty(node)) {
+ if (t.isFunctionTypeAnnotation(node.value)) {
+ findKind(node.value);
+ } else {
+ comment.kind = 'member';
+ }
+ } else if (t.isTSEnumDeclaration(node)) {
+ comment.kind = 'enum';
+ }
+ }
+
+ if (comment.context.ast) {
+ findKind(comment.context.ast.node);
+ }
+
+ return comment;
+}
diff --git a/src/infer/membership.js b/src/infer/membership.js
new file mode 100644
index 000000000..756d43e3b
--- /dev/null
+++ b/src/infer/membership.js
@@ -0,0 +1,496 @@
+import n from '@babel/types';
+import pathParse from 'parse-filepath';
+import isJSDocComment from '../is_jsdoc_comment.js';
+import parse from '../parse.js';
+
+function inferModuleName(comment) {
+ return (
+ (comment.kind === 'module' && comment.name) ||
+ pathParse(comment.context.file).name
+ );
+}
+
+/**
+ * Given an AST node, try to find a comment in front of it that
+ * has a `lends` tag, and if it has that, return the tag, split by
+ * .s.
+ *
+ * @private
+ * @param {Object} path AST node
+ * @returns {string|undefined} lends identifier, if any
+ */
+function findLendsIdentifiers(path) {
+ if (!path || !path.get('leadingComments')) {
+ return;
+ }
+
+ const leadingComments = path.get('leadingComments');
+
+ for (let i = 0; i < leadingComments.length; i++) {
+ const comment = leadingComments[i];
+ if (isJSDocComment(comment.node)) {
+ const lends = parse(comment.node.value).lends;
+ if (lends) {
+ return lends.split('.');
+ }
+ }
+ }
+}
+
+/**
+ * Given an AST node, try to find a comment before the class declaration that
+ * has a `memberof` tag, and if it has that, return the tag, split by
+ * .s with the name of the class.
+ *
+ * @private
+ * @param {Object} path AST node
+ * @returns {Array} class membership
+ */
+function inferClassMembership(path) {
+ if (path.get('leadingComments')) {
+ const leadingComments = path.get('leadingComments');
+
+ for (let i = leadingComments.length - 1; i >= 0; i--) {
+ const comment = leadingComments[i];
+ if (isJSDocComment(comment.node)) {
+ const memberof = parse(comment.node.value).memberof;
+ if (memberof) {
+ return [...memberof.split('.'), path.node.id.name];
+ }
+ }
+ }
+ }
+
+ return [path.node.id.name];
+}
+
+/**
+ * Extract and return the identifiers for expressions of
+ * type this.foo
+ *
+ * @param {NodePath} path AssignmentExpression, MemberExpression,
+ * or Identifier
+ * @param {Comment} comment
+ * @returns {Array} identifiers
+ * @private
+ */
+function extractThis(path, comment) {
+ let identifiers = [];
+
+ path.traverse({
+ /**
+ * Add the resolved identifier of this in a path to the identifiers array
+ * @param {Object} path ast path
+ * @returns {undefined} has side-effects
+ * @private
+ */
+ ThisExpression(path) {
+ let scope = path.scope;
+
+ while (n.isBlockStatement(scope.block)) {
+ scope = scope.parent;
+ }
+
+ if (
+ n.isClassMethod(scope.block) &&
+ scope.path.parentPath.parentPath.node.id !== null
+ ) {
+ identifiers.push(
+ scope.path.parentPath.parentPath.node.id.name,
+ 'prototype'
+ );
+ }
+
+ // function OldClass() { this.foo = 1 }
+ if (n.isFunctionDeclaration(scope.block)) {
+ // named function like
+ // function OldClass() { ... }
+ if (scope.block.id) {
+ identifiers.push(scope.block.id.name, 'prototype');
+ } else if (n.isExportDefaultDeclaration(path.scope.parentBlock)) {
+ identifiers.push(inferModuleName(comment));
+ }
+ // var Binding = function OldClass() { this.foo = 1 }
+ } else if (n.isFunctionExpression(scope.block)) {
+ if (scope.path.parentPath.isVariableDeclarator()) {
+ /** var Bar = function(foo) { this.foo = foo; }; */
+ identifiers = identifiers
+ .concat(scope.path.parentPath.get('id').node.name)
+ .concat('prototype');
+ } else if (scope.path.parentPath.isAssignmentExpression()) {
+ /** this.Bar = function(foo) { this.foo = foo; }; */
+ identifiers = identifiers
+ .concat(extractIdentifiers(scope.path.parentPath.get('left')))
+ .concat('prototype');
+ }
+ }
+ }
+ });
+
+ return identifiers;
+}
+
+/**
+ * Extract and return the chain of identifiers from the left hand side of expressions
+ * of the forms `Foo = ...`, `Foo.bar = ...`, `Foo.bar.baz = ...`, etc.
+ *
+ * @param {NodePath} path AssignmentExpression, MemberExpression, or Identifier
+ * @returns {Array} identifiers
+ * @private
+ */
+function extractIdentifiers(path) {
+ const identifiers = [];
+
+ path.traverse({
+ /**
+ * Add an identifier in a path to the identifiers array
+ * @param {Object} path ast path
+ * @returns {undefined} has side-effects
+ * @private
+ */
+ Identifier(path) {
+ identifiers.push(path.node.name);
+ }
+ });
+
+ return identifiers;
+}
+
+/**
+ * Count leading identifiers that refer to a module export (`exports` or `module.exports`).
+ * @private
+ * @param {Object} comment parsed comment
+ * @param {Array} identifiers array of identifier names
+ * @returns {number} number of identifiers referring to a module export (0, 1 or 2)
+ */
+function countModuleIdentifiers(comment, identifiers) {
+ if (identifiers.length >= 1 && identifiers[0] === 'exports') {
+ return 1;
+ }
+
+ if (
+ identifiers.length >= 2 &&
+ identifiers[0] === 'module' &&
+ identifiers[1] === 'exports'
+ ) {
+ return 2;
+ }
+
+ return 0;
+}
+
+/**
+ * Returns the comment object after normalizing Foo.prototype and Foo# expressions
+ * @param comment parsed comment
+ * @returns the normalized comment
+ */
+function normalizeMemberof(comment) {
+ if (typeof comment.memberof != 'string') {
+ return comment;
+ }
+
+ const memberof = comment.memberof;
+
+ const isPrototype = /.prototype$/;
+
+ if (memberof.match(isPrototype) !== null) {
+ comment.memberof = memberof.replace(isPrototype, '');
+ comment.scope = 'instance';
+
+ return comment;
+ }
+
+ const isInstanceMember = /#$/;
+
+ if (memberof.match(isInstanceMember) !== null) {
+ comment.memberof = memberof.replace(isInstanceMember, '');
+ comment.scope = 'instance';
+ }
+
+ return comment;
+}
+
+/**
+ * Uses code structure to infer `memberof`, `instance`, and `static`
+ * tags from the placement of JSDoc
+ * annotations within a file
+ *
+ * @private
+ * @returns {Object} comment with membership inferred
+ */
+export default function () {
+ let currentModule;
+
+ /**
+ * Set `memberof` and `instance`/`static` tags on `comment` based on the
+ * array of `identifiers`. If the last element of the `identifiers` is
+ * `"prototype"`, it is assumed to be an instance member; otherwise static.
+ * If the `identifiers` start with `exports` or `module.exports`, assign
+ * membership based on the last seen @module tag or name of the current file.
+ *
+ * @param {Object} comment comment for which to infer memberships
+ * @param {Array} identifiers array of identifier names
+ * @param {string} explicitScope if derived from an es6 class, whether or
+ * not this method had the static keyword
+ * @returns {Comment} returns mutated `comment`
+ * @private
+ */
+ function inferMembershipFromIdentifiers(comment, identifiers, explicitScope) {
+ if (
+ identifiers.length === 1 &&
+ identifiers[0] === 'module' &&
+ comment.name === 'exports'
+ ) {
+ comment.name = inferModuleName(currentModule || comment);
+ return comment;
+ }
+
+ /*
+ * Test whether identifiers start with a module export (`exports` or `module.exports`),
+ * and if so replace those identifiers with the name of the current module.
+ */
+ const moduleIdentifierCount = countModuleIdentifiers(comment, identifiers);
+ if (moduleIdentifierCount) {
+ identifiers = identifiers.slice(moduleIdentifierCount);
+ identifiers.unshift(inferModuleName(currentModule || comment));
+ }
+
+ if (identifiers[identifiers.length - 1] === 'prototype') {
+ comment.memberof = identifiers.slice(0, -1).join('.');
+ comment.scope = 'instance';
+ } else {
+ comment.memberof = identifiers.join('.');
+ if (explicitScope !== undefined) {
+ comment.scope = explicitScope;
+ } else {
+ comment.scope = 'static';
+ }
+ }
+ return comment;
+ }
+
+ return function inferMembership(comment) {
+ // Lends tags are go-betweens that let people reassign membership
+ // in bulk: they themselves don't get an inference step
+ if (comment.lends) {
+ return comment;
+ }
+
+ if (comment.kind === 'module') {
+ currentModule = comment;
+ }
+
+ // If someone explicitly specifies the parent of this chunk, don't
+ // try to infer it, just return what they specified.
+ if (comment.memberof) {
+ return normalizeMemberof(comment);
+ }
+
+ let path = comment.context.ast;
+ // If this chunk doesn't have code attached, like if it was the result
+ // of a polyglot parse, don't try to infer anything.
+ if (!path) {
+ return comment;
+ }
+
+ // INFERENCE ===============================================================
+ // Deal with an oddity of espree: the jsdoc comment is attached to a different
+ // node in the two expressions `a.b = c` vs `a.b = function () {}`.
+ if (
+ path.isExpressionStatement() &&
+ path.get('expression').isAssignmentExpression() &&
+ path.get('expression').get('left').isMemberExpression()
+ ) {
+ path = path.get('expression').get('left');
+ }
+
+ // Same as above but for `b: c` vs `b: function () {}`.
+ if (
+ path.isObjectProperty() &&
+ (path.get('key').isIdentifier() || path.get('key').isLiteral())
+ ) {
+ path = path.get('key');
+ }
+
+ // Forms:
+ //
+ // Foo.bar = ...;
+ // Foo.prototype.bar = ...;
+ // Foo.bar.baz = ...;
+ //
+ // Lends is not supported in this codepath.
+ if (path.isMemberExpression()) {
+ const memberIdentifiers = [].concat(
+ extractThis(path, comment),
+ extractIdentifiers(path)
+ );
+ if (memberIdentifiers.length >= 2) {
+ return inferMembershipFromIdentifiers(
+ comment,
+ memberIdentifiers.slice(0, -1)
+ );
+ }
+ return comment;
+ }
+
+ // Like straight membership, classes don't need
+ // to support lends.
+ //
+ // class Foo { bar() { } }
+ // var Foo = class { bar() { } }
+ // class Foo { prop: T }
+ // var Foo = class { prop: T }
+ if (
+ (path.isClassMethod() ||
+ path.isClassProperty() ||
+ path.isTSDeclareMethod()) &&
+ path.parentPath.isClassBody() &&
+ path.parentPath.parentPath.isClass()
+ ) {
+ let scope = 'instance';
+ if (path.node.static == true) {
+ scope = 'static';
+ }
+
+ if (path.parentPath.parentPath.isExpression()) {
+ return inferMembershipFromIdentifiers(
+ comment,
+ extractIdentifiers(path.parentPath.parentPath.parentPath.get('left')),
+ scope
+ );
+ }
+
+ const declarationNode = path.parentPath.parentPath.node;
+ if (!declarationNode.id && !declarationNode.key) {
+ // export default function () {}
+ // export default class {}
+ // Use module name instead.
+ return inferMembershipFromIdentifiers(
+ comment,
+ [pathParse(comment.context.file).name],
+ scope
+ );
+ }
+
+ return inferMembershipFromIdentifiers(
+ comment,
+ inferClassMembership(path.parentPath.parentPath),
+ scope
+ );
+ }
+
+ // Whether something is an ObjectMethod (shorthand like foo() {} )
+ // or ObjectProperty (old fashioned like foo: function() {} )
+ // doesn't matter for the membership phase, as long as we end up knowing
+ // that it belongs to an object. So we first establish objectParent,
+ // and then have the logic for the numerous ways an object can be named.
+ let objectParent;
+
+ if (
+ (path.isIdentifier() || path.isLiteral()) &&
+ path.parentPath.isObjectProperty() &&
+ path.parentPath.parentPath.isObjectExpression()
+ ) {
+ objectParent = path.parentPath.parentPath;
+ } else if (path.isObjectMethod() && path.parentPath.isObjectExpression()) {
+ objectParent = path.parentPath;
+ } else if (path.isObjectTypeProperty() || path.isTSTypeElement()) {
+ objectParent = path.parentPath;
+ }
+
+ // Confirm that the thing being documented is a property of an object.
+ if (objectParent) {
+ // Collect all keys of parent nested object keys, e.g. {foo: bar: {baz: 1}}
+ const objectKeys = [];
+
+ while (!objectParent.isStatement()) {
+ if (
+ objectParent.isObjectProperty() ||
+ objectParent.isObjectTypeProperty() ||
+ objectParent.isTSPropertySignature()
+ ) {
+ objectKeys.unshift(objectParent.node.key.name);
+ }
+
+ // The @lends comment is sometimes attached to the first property rather than
+ // the object expression itself.
+ const lendsIdentifiers =
+ findLendsIdentifiers(objectParent) ||
+ findLendsIdentifiers(objectParent.get('properties')[0]);
+
+ if (lendsIdentifiers) {
+ return inferMembershipFromIdentifiers(comment, [
+ ...lendsIdentifiers,
+ ...objectKeys
+ ]);
+ } else if (objectParent.parentPath.isAssignmentExpression()) {
+ // Foo = { ... };
+ // Foo.prototype = { ... };
+ // Foo.bar = { ... };
+ return inferMembershipFromIdentifiers(comment, [
+ ...extractIdentifiers(objectParent.parentPath.get('left')),
+ ...objectKeys
+ ]);
+ } else if (objectParent.parentPath.isVariableDeclarator()) {
+ // var Foo = { ... };
+ return inferMembershipFromIdentifiers(comment, [
+ objectParent.parentPath.get('id').node.name,
+ ...objectKeys
+ ]);
+ } else if (objectParent.parentPath.isExportDefaultDeclaration()) {
+ // export default { ... };
+ return inferMembershipFromIdentifiers(comment, [
+ inferModuleName(currentModule || comment),
+ ...objectKeys
+ ]);
+ } else if (
+ objectParent.parentPath.isTypeAlias() ||
+ objectParent.parentPath.isTSTypeAliasDeclaration()
+ ) {
+ // type X = { ... }
+ return inferMembershipFromIdentifiers(comment, [
+ objectParent.parentPath.node.id.name,
+ ...objectKeys
+ ]);
+ } else if (
+ objectParent.parentPath.isInterfaceDeclaration() ||
+ objectParent.parentPath.isTSInterfaceDeclaration()
+ ) {
+ // interface Foo { ... }
+ return inferMembershipFromIdentifiers(
+ comment,
+ [...inferClassMembership(objectParent.parentPath), ...objectKeys],
+ 'instance'
+ );
+ }
+
+ objectParent = objectParent.parentPath;
+ }
+ }
+
+ // TypeScript enums
+ // enum Foo { A }
+ if (path.isTSEnumMember()) {
+ const enumPath = path.parentPath;
+ return inferMembershipFromIdentifiers(
+ comment,
+ [enumPath.node.id.name],
+ 'static'
+ );
+ }
+
+ // var function Foo() {
+ // function bar() {}
+ // return { bar: bar };
+ // }
+ /*
+ if (n.isFunctionDeclaration(path) &&
+ n.isBlockStatement(path.parentPath) &&
+ n.isFunction(path.parentPath.parentPath)) {
+ inferMembershipFromIdentifiers(comment, [path.parentPath.parentPath.node.id.name]);
+ }
+ */
+
+ return comment;
+ };
+}
diff --git a/src/infer/name.js b/src/infer/name.js
new file mode 100644
index 000000000..0b8af39b0
--- /dev/null
+++ b/src/infer/name.js
@@ -0,0 +1,100 @@
+import pathParse from 'parse-filepath';
+import t from '@babel/types';
+
+/**
+ * Infers a `name` tag from the context.
+ *
+ * @name inferName
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with name inferred
+ */
+export default function inferName(comment) {
+ if (comment.name) {
+ return comment;
+ }
+
+ if (comment.alias) {
+ comment.name = comment.alias;
+ return comment;
+ }
+
+ if (comment.kind === 'module') {
+ comment.name = pathParse(comment.context.file).name;
+ return comment;
+ }
+
+ function inferName(path, node) {
+ if (node && node.name) {
+ comment.name = node.name;
+ return true;
+ }
+ if (node && node.type === 'StringLiteral' && node.value) {
+ comment.name = node.value;
+ return true;
+ }
+ }
+
+ const path = comment.context.ast;
+ if (path) {
+ if (path.type === 'ExportDefaultDeclaration') {
+ if (t.isDeclaration(path.node.declaration) && path.node.declaration.id) {
+ comment.name = path.node.declaration.id.name;
+ } else {
+ comment.name = pathParse(comment.context.file).name;
+ }
+ return comment;
+ }
+
+ // The strategy here is to do a depth-first traversal of the AST,
+ // looking for nodes with a "name" property, with exceptions as needed.
+ // For example, name inference for a MemberExpression `foo.bar = baz` will
+ // infer the named based on the `property` of the MemberExpression (`bar`)
+ // rather than the `object` (`foo`).
+ path.traverse({
+ /**
+ * Attempt to extract the name from an Identifier node.
+ * If the name can be resolved, it will stop traversing.
+ * @param {Object} path ast path
+ * @returns {undefined} has side-effects
+ * @private
+ */
+ Identifier(path) {
+ if (inferName(path, path.node)) {
+ path.stop();
+ }
+ },
+ /**
+ * Attempt to extract the name from a string literal that is the `key`
+ * part of an ObjectProperty node. If the name can be resolved, it
+ * will stop traversing.
+ * @param {Object} path ast path
+ * @returns {undefined} has side-effects
+ * @private
+ */
+ StringLiteral(path) {
+ if (
+ path.parent.type === 'ObjectProperty' &&
+ path.node === path.parent.key
+ ) {
+ if (inferName(path, path.node)) {
+ path.stop();
+ }
+ }
+ },
+ /**
+ * Attempt to extract the name from an Identifier node.
+ * If the name can be resolved, it will stop traversing.
+ * @param {Object} path ast path
+ * @returns {undefined} has side-effects
+ * @private
+ */
+ MemberExpression(path) {
+ if (inferName(path, path.node.property)) {
+ path.stop();
+ }
+ }
+ });
+ }
+
+ return comment;
+}
diff --git a/src/infer/params.js b/src/infer/params.js
new file mode 100644
index 000000000..2103af6df
--- /dev/null
+++ b/src/infer/params.js
@@ -0,0 +1,418 @@
+import t from '@babel/types';
+import babelGenerate from '@babel/generator';
+import _ from 'lodash';
+import findTarget from './finders.js';
+import typeAnnotation from '../type_annotation.js';
+
+const generate = babelGenerate.default || babelGenerate;
+
+/**
+ * Infers param tags by reading function parameter names
+ *
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with parameters
+ */
+export default function inferParams(comment) {
+ let path = findTarget(comment.context.ast);
+ if (!path) {
+ return comment;
+ }
+
+ // In case of `/** */ var x = function () {}` findTarget returns
+ // the declarator.
+ if (t.isVariableDeclarator(path)) {
+ path = path.get('init');
+ }
+
+ // If this is an ES6 class with a constructor method, infer
+ // parameters from that constructor method.
+ if (
+ t.isClassDeclaration(path) &&
+ !(comment.constructorComment && comment.constructorComment.hideconstructor)
+ ) {
+ const constructor = path.node.body.body.find(item => {
+ // https://github.com/babel/babylon/blob/master/ast/spec.md#classbody
+ return t.isClassMethod(item) && item.kind === 'constructor';
+ });
+ if (constructor) {
+ return inferAndCombineParams(constructor.params, comment);
+ }
+ }
+
+ if (
+ !t.isFunction(path) &&
+ !t.isTSDeclareFunction(path) &&
+ !t.isTSDeclareMethod(path) &&
+ !t.isFunctionTypeAnnotation(path) &&
+ !t.isTSMethodSignature(path)
+ ) {
+ return comment;
+ }
+
+ if (comment.kind === 'class' && comment.hideconstructor) {
+ return comment;
+ }
+
+ let params = t.isTSMethodSignature(path)
+ ? path.node.parameters
+ : path.node.params;
+
+ // Flow function annotations separate rest parameters into a different list
+ if (t.isFunctionTypeAnnotation(path) && path.node.rest) {
+ params = params.concat(path.node.rest);
+ }
+
+ const result = inferAndCombineParams(params, comment);
+
+ // Wrap flow rest parameter with a RestType
+ if (t.isFunctionTypeAnnotation(path) && path.node.rest) {
+ const rest = result.params[result.params.length - 1];
+ rest.type = {
+ type: 'RestType',
+ expression: rest.type
+ };
+ }
+
+ return result;
+}
+
+function inferAndCombineParams(params, comment) {
+ const inferredParams = params.map((param, i) => {
+ const doc = paramToDoc(param, '', i);
+ if (param.optional) {
+ doc.type = {
+ type: 'OptionalType',
+ expression: doc.type
+ };
+ }
+
+ return doc;
+ });
+ const paramsToMerge = comment.params;
+ if (comment.constructorComment) {
+ paramsToMerge.push.apply(paramsToMerge, comment.constructorComment.params);
+ }
+ const mergedParamsAndErrors = mergeTrees(inferredParams, paramsToMerge);
+
+ // Then merge the trees. This is the hard part.
+ return Object.assign(comment, {
+ params: mergedParamsAndErrors.mergedParams,
+ errors: comment.errors.concat(mergedParamsAndErrors.errors)
+ });
+}
+
+// Utility methods ============================================================
+//
+const PATH_SPLIT_CAPTURING = /(\[])?(\.)/g;
+const PATH_SPLIT = /(?:\[])?\./g;
+function tagDepth(tag) {
+ return (tag.name || '').split(PATH_SPLIT).length;
+}
+
+/**
+ * Index tags by their `name` property into an ES6 map.
+ */
+function mapTags(tags) {
+ return new Map(
+ tags.map(tag => {
+ return [tag.name, tag];
+ })
+ );
+}
+
+/**
+ * Babel parses JavaScript source code and produces an abstract syntax
+ * tree that includes methods and their arguments. This function takes
+ * that AST and uses it to infer details that would otherwise need
+ * explicit documentation, like the names of comments and their
+ * default values.
+ *
+ * It is especially careful to allow the user and the machine to collaborate:
+ * documentation.js should not overwrite any details that the user
+ * explicitly sets.
+ *
+ * @private
+ * @param {Object} param the abstract syntax tree of the parameter in JavaScript
+ * @param {number} i the number of this parameter, in argument order
+ * @param {string} prefix of the comment, if it is nested, like in the case of destructuring
+ * @returns {Object} parameter with inference.
+ */
+function paramToDoc(param, prefix, i) {
+ const autoName = '$' + String(i);
+ const prefixedName = prefix + '.' + param.name;
+
+ switch (param.type) {
+ case 'AssignmentPattern': {
+ // (a = b)
+ const newAssignmentParam = paramToDoc(param.left, '', i);
+
+ if (Array.isArray(newAssignmentParam)) {
+ throw new Error('Encountered an unexpected parameter type');
+ }
+
+ return Object.assign(newAssignmentParam, {
+ default: generate(param.right, {
+ compact: true
+ }).code,
+ type: newAssignmentParam.type
+ });
+ }
+ // ObjectPattern
+ case 'ObjectPattern': {
+ // { a }
+ if (prefix === '') {
+ // If this is a root-level param, like f({ x }), then we need to name
+ // it, like $0 or $1, depending on its position.
+ return {
+ title: 'param',
+ name: autoName,
+ anonymous: true,
+ type: (param.typeAnnotation &&
+ typeAnnotation(param.typeAnnotation)) || {
+ type: 'NameExpression',
+ name: 'Object'
+ },
+ properties: _.flatMap(param.properties, prop => {
+ return paramToDoc(prop, prefix + autoName);
+ })
+ };
+ } else if (param.indexed) {
+ // Likewise, if this object pattern sits inside of an ArrayPattern,
+ // like [{ foo }], it shouldn't just look like $0.foo, but like $0.0.foo,
+ // so make sure it isn't indexed first.
+ return {
+ title: 'param',
+ name: prefixedName,
+ anonymous: true,
+ type: (param.typeAnnotation &&
+ typeAnnotation(param.typeAnnotation)) || {
+ type: 'NameExpression',
+ name: 'Object'
+ },
+ properties: _.flatMap(param.properties, prop => {
+ return paramToDoc(prop, prefixedName);
+ })
+ };
+ }
+ // If, otherwise, this is nested, we don't really represent it as
+ // a parameter in and of itself - we just want its children, and
+ // it will be the . in obj.prop
+ return _.flatMap(param.properties, prop => {
+ return paramToDoc(prop, prefix);
+ });
+ }
+ // ArrayPattern
+ case 'ArrayPattern': {
+ // ([a, b, { c }])
+ if (prefix === '') {
+ return {
+ title: 'param',
+ name: autoName,
+ anonymous: true,
+ type: (param.typeAnnotation &&
+ typeAnnotation(param.typeAnnotation)) || {
+ type: 'NameExpression',
+ name: 'Array'
+ },
+ // Array destructuring lets you name the elements in the array,
+ // but those names don't really make sense within the JSDoc
+ // indexing tradition, or have any external meaning. So
+ // instead we're going to (immutably) rename the parameters to their
+ // indices
+ properties: _.flatMap(param.elements, (element, idx) => {
+ const indexedElement = Object.assign({}, element, {
+ name: String(idx),
+ indexed: true
+ });
+ return paramToDoc(indexedElement, autoName);
+ })
+ };
+ }
+ return _.flatMap(param.elements, (element, idx) => {
+ const indexedElement = Object.assign({}, element, {
+ name: String(idx)
+ });
+ return paramToDoc(indexedElement, prefix);
+ });
+ }
+ case 'ObjectProperty': {
+ return Object.assign(
+ paramToDoc(
+ param.value,
+ prefix + '.' + param.key.name || param.key.value
+ ),
+ {
+ name: prefix + '.' + param.key.name || param.key.value
+ }
+ );
+ }
+ case 'RestProperty': // (a, ...b)
+ case 'RestElement': {
+ const type = {
+ type: 'RestType'
+ };
+ if (param.typeAnnotation) {
+ type.expression = typeAnnotation(param.typeAnnotation);
+ }
+ return {
+ title: 'param',
+ name: prefix ? `${prefix}.${param.argument.name}` : param.argument.name,
+ lineNumber: param.loc.start.line,
+ type
+ };
+ }
+ case 'FunctionTypeParam': // flow interface method signature
+ return {
+ title: 'param',
+ name: prefix ? prefix + '.' + param.name.name : param.name.name,
+ lineNumber: param.loc.start.line,
+ type: param.typeAnnotation
+ ? typeAnnotation(param.typeAnnotation)
+ : undefined
+ };
+ default: {
+ // (a)
+ const newParam = {
+ title: 'param',
+ name: prefix ? prefixedName : param.name,
+ // A skipped array argument like ([, a]);
+ // looks like { name: '0', indexed: true }, and thus has no location,
+ // so we allow location to be undefined here.
+ lineNumber: param.loc ? param.loc.start.line : undefined
+ };
+
+ // Flow/TS annotations
+ if (param.typeAnnotation && param.typeAnnotation.typeAnnotation) {
+ newParam.type = typeAnnotation(param.typeAnnotation.typeAnnotation);
+ }
+
+ return newParam;
+ }
+ }
+}
+
+/**
+ * Recurse through a potentially nested parameter tag,
+ * replacing the auto-generated name, like $0, with an explicit
+ * name provided from a JSDoc comment. For instance, if you have a code
+ * block like
+ *
+ * function f({ x });
+ *
+ * It would by default be documented with a first param $0, with a member $0.x
+ *
+ * If you specify the name of the param, then it could be documented with, say,
+ * options and options.x. So we need to recursively rename not just $0 but
+ * also $0.x and maybe $0.x.y.z all to options.x and options.x.y.z
+ */
+function renameTree(node, explicitName) {
+ const parts = node.name.split(PATH_SPLIT_CAPTURING);
+ parts[0] = explicitName;
+ node.name = parts.join('');
+ if (node.properties) {
+ node.properties.forEach(property => renameTree(property, explicitName));
+ }
+}
+
+export function mergeTrees(inferred, explicit) {
+ // The first order of business is ensuring that the root types are specified
+ // in the right order. For the order of arguments, the inferred reality
+ // is the ground-truth: a function like
+ // function addThem(a, b, c) {}
+ // Should always see (a, b, c) in that order
+
+ // First, if all parameters are specified, allow explicit names to apply
+ // to destructuring parameters, which do not have inferred names. This is
+ // _only_ enabled in the case in which all parameters are specified explicitly
+ if (inferred.length === explicit.length) {
+ for (let i = 0; i < inferred.length; i++) {
+ if (inferred[i].anonymous === true) {
+ renameTree(inferred[i], explicit[i].name);
+ }
+ }
+ }
+
+ return mergeTopNodes(inferred, explicit);
+}
+
+function mergeTopNodes(inferred, explicit) {
+ const mapExplicit = mapTags(explicit);
+ const inferredNames = new Set(inferred.map(tag => tag.name));
+ const explicitTagsWithoutInference = explicit.filter(tag => {
+ return tagDepth(tag) === 1 && !inferredNames.has(tag.name);
+ });
+
+ const errors = explicitTagsWithoutInference.map(tag => {
+ return {
+ message:
+ `An explicit parameter named ${
+ tag.name || ''
+ } was specified but didn't match ` +
+ `inferred information ${Array.from(inferredNames).join(', ')}`,
+ commentLineNumber: tag.lineNumber
+ };
+ });
+
+ return {
+ errors,
+ mergedParams: inferred
+ .map(inferredTag => {
+ const explicitTag = mapExplicit.get(inferredTag.name);
+ return explicitTag
+ ? combineTags(inferredTag, explicitTag)
+ : inferredTag;
+ })
+ .concat(explicitTagsWithoutInference)
+ };
+}
+
+// This method is used for _non-root_ properties only - we use mergeTopNodes
+// for root properties, which strictly requires inferred only. In this case,
+// we combine all tags:
+// - inferred & explicit
+// - explicit only
+// - inferred only
+function mergeNodes(inferred, explicit) {
+ const intersection = _.intersectionBy(inferred, explicit, tag => tag.name);
+ const explicitOnly = _.differenceBy(explicit, inferred, tag => tag.name);
+ const inferredOnly = _.differenceBy(inferred, explicit, tag => tag.name);
+ const mapExplicit = mapTags(explicit);
+
+ return intersection
+ .map(inferredTag => {
+ const explicitTag = mapExplicit.get(inferredTag.name);
+ return explicitTag ? combineTags(inferredTag, explicitTag) : inferredTag;
+ })
+ .concat(explicitOnly)
+ .concat(inferredOnly);
+}
+
+function combineTags(inferredTag, explicitTag) {
+ let type = explicitTag.type;
+ let defaultValue;
+ if (!explicitTag.type) {
+ type = inferredTag.type;
+ }
+
+ if (!explicitTag.default && inferredTag.default) {
+ defaultValue = inferredTag.default;
+ }
+
+ const hasProperties =
+ (inferredTag.properties && inferredTag.properties.length) ||
+ (explicitTag.properties && explicitTag.properties.length);
+
+ return Object.assign(
+ explicitTag,
+ hasProperties
+ ? {
+ properties: mergeNodes(
+ inferredTag.properties || [],
+ explicitTag.properties || []
+ )
+ }
+ : {},
+ { type },
+ defaultValue ? { default: defaultValue } : {}
+ );
+}
diff --git a/src/infer/properties.js b/src/infer/properties.js
new file mode 100644
index 000000000..0560d1e1a
--- /dev/null
+++ b/src/infer/properties.js
@@ -0,0 +1,110 @@
+import typeAnnotation from '../type_annotation.js';
+import findTarget from './finders.js';
+
+function prefixedName(name, prefix) {
+ if (prefix.length) {
+ return prefix.join('.') + '.' + name;
+ }
+ return name;
+}
+
+function isObjectSpreadAndExactUtilTypeProperty(property) {
+ return (
+ property.type === 'ObjectTypeSpreadProperty' &&
+ property.argument.id.name === '$Exact'
+ );
+}
+
+function propertyToDoc(property, prefix) {
+ let type;
+ let name;
+
+ if (property.type === 'ObjectTypeProperty') {
+ // flow
+ type = typeAnnotation(property.value);
+ } else if (property.type === 'TSPropertySignature') {
+ // typescript
+ type = typeAnnotation(property.typeAnnotation);
+ } else if (property.type === 'TSMethodSignature') {
+ // typescript
+ type = typeAnnotation(property);
+ }
+
+ if (property.key) {
+ name = property.key.name || property.key.value;
+ }
+
+ // Special handling for { ...$Exact }
+ if (isObjectSpreadAndExactUtilTypeProperty(property)) {
+ name = property.argument.id.name;
+ type = {
+ type: 'NameExpression',
+ name: property.argument.typeParameters.params[0].id.name
+ };
+ }
+
+ if (property.optional) {
+ type = {
+ type: 'OptionalType',
+ expression: type
+ };
+ }
+ return {
+ title: 'property',
+ name: prefixedName(name, prefix),
+ lineNumber: property.loc.start.line,
+ type
+ };
+}
+
+/**
+ * Infers properties of TypeAlias objects (Flow or TypeScript type definitions)
+ *
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with inferred properties
+ */
+export default function inferProperties(comment) {
+ const explicitProperties = new Set();
+ // Ensure that explicitly specified properties are not overridden
+ // by inferred properties
+ comment.properties.forEach(prop => explicitProperties.add(prop.name));
+
+ function inferProperties(value, prefix) {
+ if (
+ value.type === 'ObjectTypeAnnotation' ||
+ value.type === 'TSTypeLiteral'
+ ) {
+ const properties = value.properties || value.members || value.body || [];
+ properties.forEach(function (property) {
+ let name;
+
+ if (property.key) {
+ name = property.key.name;
+ }
+
+ // Special handling for { ...$Exact }
+ if (isObjectSpreadAndExactUtilTypeProperty(property)) {
+ name = property.argument.id.name;
+ }
+
+ if (!explicitProperties.has(prefixedName(name, prefix))) {
+ comment.properties = comment.properties.concat(
+ propertyToDoc(property, prefix)
+ );
+ }
+ });
+ }
+ }
+
+ const path = findTarget(comment.context.ast);
+
+ if (path) {
+ if (path.isTypeAlias()) {
+ inferProperties(path.node.right, []);
+ } else if (path.isTSTypeAliasDeclaration()) {
+ inferProperties(path.node.typeAnnotation, []);
+ }
+ }
+
+ return comment;
+}
diff --git a/src/infer/return.js b/src/infer/return.js
new file mode 100644
index 000000000..a33917599
--- /dev/null
+++ b/src/infer/return.js
@@ -0,0 +1,114 @@
+import findTarget from './finders.js';
+import t from '@babel/types';
+import typeAnnotation from '../type_annotation.js';
+
+// TypeScript does not currently support typing the return value of a generator function.
+// This is coming in TypeScript 3.3 - https://github.com/Microsoft/TypeScript/pull/30790
+const TS_GENERATORS = {
+ Iterator: 1,
+ Iterable: 1,
+ IterableIterator: 1
+};
+
+const FLOW_GENERATORS = {
+ Iterator: 1,
+ Iterable: 1,
+ Generator: 3
+};
+
+/**
+ * Infers returns tags by using Flow return type annotations
+ *
+ * @name inferReturn
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with return tag inferred
+ */
+export default function inferReturn(comment) {
+ if (
+ Array.isArray(comment.returns) &&
+ comment.returns.length &&
+ comment.returns[0].type
+ ) {
+ return comment;
+ }
+ const path = findTarget(comment.context.ast);
+ let fn = path && path.node;
+ if (!fn) {
+ return comment;
+ }
+
+ // In case of `/** */ var x = function () {}` findTarget returns
+ // the declarator.
+ if (t.isVariableDeclarator(fn)) {
+ fn = fn.init;
+ }
+
+ const fnReturnType = getReturnType(fn);
+ if (fnReturnType) {
+ let returnType = typeAnnotation(fnReturnType);
+ let yieldsType = null;
+
+ if (fn.generator && returnType.type === 'TypeApplication') {
+ comment.generator = true;
+ let numArgs;
+
+ if (t.isFlow(fnReturnType)) {
+ numArgs = FLOW_GENERATORS[returnType.expression.name];
+ } else if (t.isTSTypeAnnotation(fnReturnType)) {
+ numArgs = TS_GENERATORS[returnType.expression.name];
+ }
+
+ if (returnType.applications.length === numArgs) {
+ yieldsType = returnType.applications[0];
+
+ if (numArgs > 1) {
+ returnType = returnType.applications[1];
+ } else {
+ returnType = {
+ type: 'VoidLiteral'
+ };
+ }
+ }
+ }
+
+ if (yieldsType) {
+ if (comment.yields && comment.yields.length > 0) {
+ comment.yields[0].type = yieldsType;
+ } else {
+ comment.yields = [
+ {
+ title: 'yields',
+ type: yieldsType
+ }
+ ];
+ }
+ }
+
+ if (comment.returns && comment.returns.length > 0) {
+ comment.returns[0].type = returnType;
+ } else {
+ comment.returns = [
+ {
+ title: 'returns',
+ type: returnType
+ }
+ ];
+ }
+ }
+ return comment;
+}
+
+function getReturnType(fn) {
+ if (
+ t.isFunction(fn) ||
+ t.isTSDeclareFunction(fn) ||
+ t.isTSDeclareMethod(fn) ||
+ t.isFunctionTypeAnnotation(fn)
+ ) {
+ return fn.returnType;
+ }
+
+ if (t.isTSMethodSignature(fn)) {
+ return fn.typeAnnotation;
+ }
+}
diff --git a/src/infer/type.js b/src/infer/type.js
new file mode 100644
index 000000000..67779dff0
--- /dev/null
+++ b/src/infer/type.js
@@ -0,0 +1,73 @@
+import findTarget from './finders.js';
+import typeAnnotation from '../type_annotation.js';
+
+const constTypeMapping = {
+ BooleanLiteral: { type: 'BooleanTypeAnnotation' },
+ NumericLiteral: { type: 'NumberTypeAnnotation' },
+ StringLiteral: { type: 'StringTypeAnnotation' }
+};
+
+/**
+ * Infers type tags by using Flow/TypeScript type annotations
+ *
+ * @name inferType
+ * @param {Object} comment parsed comment
+ * @returns {Object} comment with type tag inferred
+ */
+export default function inferType(comment) {
+ if (comment.type) {
+ return comment;
+ }
+
+ const ast = comment.context.ast;
+ const path = findTarget(ast);
+ if (!path) {
+ return comment;
+ }
+
+ const n = path.node;
+ let type;
+ switch (n.type) {
+ case 'VariableDeclarator':
+ type = n.id.typeAnnotation;
+ if (!type && comment.kind === 'constant') {
+ type = constTypeMapping[n.init.type];
+ }
+ break;
+ case 'ClassProperty':
+ case 'TSTypeAliasDeclaration':
+ case 'TSPropertySignature':
+ type = n.typeAnnotation;
+ break;
+ case 'ClassMethod':
+ case 'TSDeclareMethod':
+ if (n.kind === 'get') {
+ type = n.returnType;
+ } else if (n.kind === 'set' && n.params[0]) {
+ type = n.params[0].typeAnnotation;
+ }
+ break;
+ case 'TypeAlias':
+ type = n.right;
+ break;
+ case 'TSEnumMember':
+ if (n.initializer) {
+ if (constTypeMapping[n.initializer.type]) {
+ type = constTypeMapping[n.initializer.type];
+ }
+ } else {
+ type = constTypeMapping.NumericLiteral;
+ }
+ break;
+ default:
+ if (ast.isObjectTypeProperty() && !ast.node.method) {
+ type = ast.node.value;
+ }
+ }
+ // Don't provide a `type` section when it's an ObjectTypeAnnotation,
+ // `properties` already exists and renders better.
+ if (type && type.type !== 'ObjectTypeAnnotation') {
+ comment.type = typeAnnotation(type);
+ }
+ return comment;
+}
diff --git a/src/input/dependency.js b/src/input/dependency.js
new file mode 100644
index 000000000..4a737e808
--- /dev/null
+++ b/src/input/dependency.js
@@ -0,0 +1,31 @@
+import mdeps from './moduleDeps.js';
+import internalOnly from '../module_filters.js';
+import smartGlob from './smart_glob.js';
+
+/**
+ * Returns a array of dependencies, given an array of entry
+ * points and an object of options to provide to module-deps.
+ *
+ * This stream requires filesystem access, and thus isn't suitable
+ * for a browser environment.
+ *
+ * @param indexes paths to entry files as strings
+ * @param config optional options passed
+ * @returns results
+ */
+export default async function dependencyStream(
+ indexes,
+ { parseExtension = [], requireExtension = [] }
+) {
+ const md = await mdeps(smartGlob(indexes, parseExtension), {
+ /**
+ * Determine whether a module should be included in documentation
+ * @param {string} id path to a module
+ * @returns {boolean} true if the module should be included.
+ */
+ filter: id => internalOnly(id),
+ extensions: [...parseExtension, ...requireExtension]
+ });
+
+ return md;
+}
diff --git a/src/input/moduleDeps.js b/src/input/moduleDeps.js
new file mode 100644
index 000000000..b2e8479fd
--- /dev/null
+++ b/src/input/moduleDeps.js
@@ -0,0 +1,108 @@
+import path from 'path';
+import util from 'util';
+import r from 'resolve';
+import readFileCode from './readFileCode.js';
+import konan from 'konan';
+import { parseToAst } from '../parsers/parse_to_ast.js';
+
+// const parseExst = ['.js', '.mjs', '.jsx', '.vue', '.ts', '.tsx'];
+const resolveExst = ['.json', '.css', '.less', '.sass'];
+const resolve = util.promisify(r);
+
+class Deps {
+ constructor(opts = {}) {
+ this.fileCache = opts.fileCache || {};
+ this.visited = {};
+ this.res = [];
+
+ this.options = { ...opts };
+ }
+
+ async flush(input) {
+ const promises = input.map(file => {
+ const dir = path.dirname(file);
+ return this.walk(file, {
+ basedir: dir,
+ filename: 'root'
+ });
+ });
+ await Promise.all(promises);
+
+ return this.res;
+ }
+
+ async readFile(file) {
+ if (this.fileCache[file]) {
+ return this.fileCache[file];
+ }
+
+ return readFileCode(file);
+ }
+
+ async walk(id, parent) {
+ const extensions = this.options.extensions;
+ const sortKey = parent.sortKey || '';
+ let file = null;
+
+ try {
+ file = await resolve(id, { ...parent, extensions });
+ } catch (err) {
+ if (err.code === 'MODULE_NOT_FOUND') {
+ console.warn(`module not found: "${id}" from file ${parent.filename}`);
+ return;
+ }
+ throw err;
+ }
+
+ if (this.visited[file] || resolveExst.includes(path.extname(file))) {
+ return file;
+ }
+ this.visited[file] = true;
+
+ const source = await this.readFile(file);
+ const depsArray = this.parseDeps(file, source);
+ if (!depsArray) {
+ return file;
+ }
+
+ const deps = {};
+ const promises = depsArray.map(async (id, i) => {
+ const filter = this.options.filter;
+ if (filter && !filter(id)) {
+ deps[id] = false;
+ return;
+ }
+ const number = i.toString().padStart(8, '0');
+ deps[id] = await this.walk(id, {
+ filename: file,
+ basedir: path.dirname(file),
+ sortKey: sortKey + '!' + file + ':' + number
+ });
+ });
+
+ await Promise.all(promises);
+
+ this.res.push({
+ id: file,
+ source,
+ deps,
+ file,
+ sortKey: sortKey + '!' + file
+ });
+ return file;
+ }
+
+ parseDeps(file, src) {
+ try {
+ const ast = parseToAst(src, file);
+ return konan(ast).strings;
+ } catch (ex) {
+ console.error(`Parsing file ${file}: ${ex}`);
+ }
+ }
+}
+
+export default async function (input = [], opts = {}) {
+ const dep = new Deps(opts);
+ return dep.flush(Array.from(new Set(input)));
+}
diff --git a/src/input/readFileCode.js b/src/input/readFileCode.js
new file mode 100644
index 000000000..5b71a610a
--- /dev/null
+++ b/src/input/readFileCode.js
@@ -0,0 +1,42 @@
+import path from 'path';
+import { readFile } from 'fs/promises';
+let vuecompiler = null;
+let vueVersion = 'v3';
+
+async function vueParser(source) {
+ if (!vuecompiler) {
+ try {
+ vuecompiler = await import('@vue/compiler-sfc');
+ } catch {
+ try {
+ vuecompiler = await import('vue-template-compiler');
+ vueVersion = 'v2';
+ } catch (err) {
+ console.error(
+ 'You need to load package vue-template-compiler for Vue 2 or @vue/compiler-sfc for Vue 3'
+ );
+ throw err;
+ }
+ }
+ }
+
+ let component = {};
+ if (vueVersion === 'v3') {
+ component = vuecompiler.parse(source).descriptor;
+ } else {
+ component = vuecompiler.parseComponent(source);
+ }
+
+ return component.script?.content || '';
+}
+
+export default async function readFileCode(file) {
+ let source = await readFile(file, {
+ encoding: 'utf8'
+ });
+
+ if (path.extname(file) === '.vue') {
+ source = await vueParser(source);
+ }
+ return source;
+}
diff --git a/src/input/shallow.js b/src/input/shallow.js
new file mode 100644
index 000000000..7ee6b6392
--- /dev/null
+++ b/src/input/shallow.js
@@ -0,0 +1,38 @@
+import smartGlob from './smart_glob.js';
+import readFileCode from './readFileCode.js';
+
+/**
+ * A readable source for content that doesn't do dependency resolution, but
+ * simply reads files and pushes them onto a stream.
+ *
+ * If an array of strings is provided as input to this method, then
+ * they will be treated as filenames and read into the stream.
+ *
+ * If an array of objects is provided, then we assume that they are valid
+ * objects with `source` and `file` properties, and don't use the filesystem
+ * at all. This is one way of getting documentation.js to run in a browser
+ * or without fs access.
+ *
+ * @param indexes entry points
+ * @param config parsing options
+ * @returns promise with parsed files
+ */
+export default async function (indexes, config) {
+ const objects = [];
+ const paths = indexes.filter(v => {
+ if (typeof v === 'object') {
+ v.file = v.file ?? '';
+ objects.push(v);
+ return false;
+ }
+ return typeof v === 'string';
+ });
+ const files = await Promise.all(
+ smartGlob(paths, config.parseExtension).map(async file => ({
+ source: await readFileCode(file),
+ file
+ }))
+ );
+
+ return [...objects, ...files];
+}
diff --git a/src/input/smart_glob.js b/src/input/smart_glob.js
new file mode 100644
index 000000000..c845d714c
--- /dev/null
+++ b/src/input/smart_glob.js
@@ -0,0 +1,131 @@
+import fs from 'fs';
+import path from 'path';
+import glob from 'glob';
+
+/**
+ * Replace Windows with posix style paths
+ *
+ * @param {string} filepath Path to convert
+ * @returns {string} Converted filepath
+ */
+function convertPathToPosix(filepath) {
+ const normalizedFilepath = path.normalize(filepath);
+ const posixFilepath = normalizedFilepath.replace(/\\/g, '/');
+
+ return posixFilepath;
+}
+
+/**
+ * Checks if a provided path is a directory and returns a glob string matching
+ * all files under that directory if so, the path itself otherwise.
+ *
+ * Reason for this is that `glob` needs `/**` to collect all the files under a
+ * directory where as our previous implementation without `glob` simply walked
+ * a directory that is passed. So this is to maintain backwards compatibility.
+ *
+ * Also makes sure all path separators are POSIX style for `glob` compatibility.
+ *
+ * @param {string[]} [extensions=['.js']] An array of accepted extensions
+ * @returns {Function} A function that takes a pathname and returns a glob that
+ * matches all files with the provided extensions if
+ * pathname is a directory.
+ */
+function processPath(extensions) {
+ const cwd = process.cwd();
+ extensions = extensions || ['.js'];
+
+ extensions = extensions.map(function (ext) {
+ return ext.replace(/^\./, '');
+ });
+
+ let suffix = '/**';
+
+ if (extensions.length === 1) {
+ suffix += '/*.' + extensions[0];
+ } else {
+ suffix += '/*.{' + extensions.join(',') + '}';
+ }
+
+ /**
+ * A function that converts a directory name to a glob pattern
+ *
+ * @param {string} pathname The directory path to be modified
+ * @returns {string} The glob path or the file path itself
+ * @private
+ */
+ return function (pathname) {
+ let newPath = pathname;
+ const resolvedPath = path.resolve(cwd, pathname);
+
+ if (
+ fs.existsSync(resolvedPath) &&
+ fs.lstatSync(resolvedPath).isDirectory()
+ ) {
+ newPath = pathname.replace(/[/\\]$/, '') + suffix;
+ }
+
+ return convertPathToPosix(newPath);
+ };
+}
+
+/**
+ * Resolves any directory patterns into glob-based patterns for easier handling.
+ * @param {string[]} patterns File patterns (such as passed on the command line).
+ * @param {Array} extensions A list of file extensions
+ * @returns {string[]} The equivalent glob patterns and filepath strings.
+ */
+function resolveFileGlobPatterns(patterns, extensions) {
+ const processPathExtensions = processPath(extensions);
+ return patterns.map(processPathExtensions);
+}
+
+/**
+ * Build a list of absolute filenames on which ESLint will act.
+ * Ignored files are excluded from the results, as are duplicates.
+ *
+ * @param globPatterns Glob patterns.
+ * @returns Resolved absolute filenames.
+ */
+function listFilesToProcess(globPatterns) {
+ const files = [];
+ const added = new Set();
+
+ const cwd = process.cwd();
+
+ /**
+ * Executes the linter on a file defined by the `filename`. Skips
+ * unsupported file extensions and any files that are already linted.
+ * @param {string} filename The file to be processed
+ * @returns {void}
+ */
+ function addFile(filename) {
+ if (added.has(filename)) {
+ return;
+ }
+ files.push(filename);
+ added.add(filename);
+ }
+
+ globPatterns.forEach(function (pattern) {
+ const file = path.resolve(cwd, pattern);
+ if (fs.existsSync(file) && fs.statSync(file).isFile()) {
+ addFile(fs.realpathSync(file));
+ } else {
+ const globOptions = {
+ nodir: true,
+ dot: true,
+ cwd
+ };
+
+ glob.sync(pattern, globOptions).forEach(function (globMatch) {
+ addFile(path.resolve(cwd, globMatch));
+ });
+ }
+ });
+
+ return files;
+}
+
+export default function smartGlob(indexes, extensions) {
+ return listFilesToProcess(resolveFileGlobPatterns(indexes, extensions));
+}
diff --git a/src/is_jsdoc_comment.js b/src/is_jsdoc_comment.js
new file mode 100644
index 000000000..1ea85e309
--- /dev/null
+++ b/src/is_jsdoc_comment.js
@@ -0,0 +1,23 @@
+/**
+ * Detect whether a comment is a JSDoc comment: it must be a block
+ * comment which starts with two asterisks, not any other number of asterisks.
+ *
+ * The code parser automatically strips out the first asterisk that's
+ * required for the comment to be a comment at all, so we count the remaining
+ * comments.
+ *
+ * @name isJSDocComment
+ * @param {Object} comment an ast path of the comment
+ * @returns {boolean} whether it is valid
+ */
+export default function isJSDocComment(
+ comment /*: {
+ value: string,
+ type: string
+}*/
+) {
+ const asterisks = comment.value.match(/^(\*+)/);
+ return (
+ comment.type === 'CommentBlock' && asterisks && asterisks[1].length === 1
+ );
+}
diff --git a/lib/lint.js b/src/lint.js
similarity index 50%
rename from lib/lint.js
rename to src/lint.js
index aa32990c0..163f864ed 100644
--- a/lib/lint.js
+++ b/src/lint.js
@@ -1,18 +1,17 @@
-'use strict';
+import { VFile } from 'vfile';
+import walk from './walk.js';
+import { sort as vfileSort } from 'vfile-sort';
+import { reporter } from 'vfile-reporter';
+import { nest } from './nest.js';
-var VFile = require('vfile'),
- walk = require('../lib/walk'),
- vfileSort = require('vfile-sort'),
- reporter = require('vfile-reporter');
-
-var CANONICAL = {
- 'String': 'string',
- 'Boolean': 'boolean',
- 'Undefined': 'undefined',
- 'Number': 'number',
- 'array': 'Array',
- 'date': 'Date',
- 'object': 'Object'
+const CANONICAL = {
+ String: 'string',
+ Boolean: 'boolean',
+ Undefined: 'undefined',
+ Number: 'number',
+ array: 'Array',
+ date: 'Date',
+ object: 'Object'
};
/**
@@ -22,12 +21,13 @@ var CANONICAL = {
* @param {Object} comment parsed comment
* @returns {Array} array of errors
*/
-function lintComments(comment) {
+export function lintComments(comment) {
comment.tags.forEach(function (tag) {
function nameInvariant(name) {
- if (CANONICAL[name]) {
+ if (name && typeof CANONICAL[name] === 'string') {
comment.errors.push({
- message: 'type ' + name + ' found, ' + CANONICAL[name] + ' is standard',
+ message:
+ 'type ' + name + ' found, ' + CANONICAL[name] + ' is standard',
commentLineNumber: tag.lineNumber
});
}
@@ -38,7 +38,12 @@ function lintComments(comment) {
nameInvariant(type.name);
}
- [type.elements, type.applications].forEach(checkSubtypes);
+ if (type.elements) {
+ checkSubtypes(type.elements);
+ }
+ if (type.applications) {
+ checkSubtypes(type.applications);
+ }
}
function checkSubtypes(subtypes) {
@@ -51,6 +56,8 @@ function lintComments(comment) {
checkCanonical(tag.type);
}
});
+ nest(comment);
+
return comment;
}
@@ -58,25 +65,22 @@ function lintComments(comment) {
* @private
* Extract lint instructions from comments and generate user-readable output.
* @param {Array} comments a list of comments
- * @return {string} user-readable output
+ * @returns {string} user-readable output
*/
-function formatLint(comments) {
- var vFiles = {};
+export function formatLint(comments) {
+ const vFiles = {};
walk(comments, function (comment) {
comment.errors.forEach(function (error) {
- var p = comment.context.file;
- vFiles[p] = vFiles[p] || new VFile({
- path: p
- });
- vFiles[p].warn(error.message, {
+ const p = comment.context.file;
+ vFiles[p] =
+ vFiles[p] ||
+ new VFile({
+ path: p
+ });
+ vFiles[p].message(error.message, {
line: comment.loc.start.line + (error.commentLineNumber || 0)
});
});
});
- return reporter(Object.keys(vFiles).map(function (p) {
- return vfileSort(vFiles[p]);
- }));
+ return reporter(Object.keys(vFiles).map(p => vfileSort(vFiles[p])));
}
-
-module.exports.lintComments = lintComments;
-module.exports.formatLint = formatLint;
diff --git a/src/merge_config.js b/src/merge_config.js
new file mode 100644
index 000000000..cea2591c6
--- /dev/null
+++ b/src/merge_config.js
@@ -0,0 +1,84 @@
+import conf from './config.js';
+import yaml from 'js-yaml';
+import fs from 'fs';
+import pify from 'pify';
+import { readPackageUp } from 'read-pkg-up';
+import path from 'path';
+import stripComments from 'strip-json-comments';
+
+function normalizeToc(config, basePath) {
+ if (!config || !config.toc) {
+ return config;
+ }
+
+ config.toc = config.toc.map(entry => {
+ if (entry && entry.file) {
+ entry.file = path.join(basePath, entry.file);
+ }
+ return entry;
+ });
+
+ return config;
+}
+
+/**
+ * Use the nearest package.json file for the default
+ * values of `name` and `version` config.
+ *
+ * @param {boolean} noPackage options which prevent ge info about project from package.json
+ * @returns {Promise} configuration with inferred parameters
+ */
+async function readPackage(noPackage) {
+ const global = conf.globalConfig;
+ if (noPackage) {
+ return {};
+ }
+ const param = ['name', 'homepage', 'version', 'description'];
+ try {
+ const { packageJson } = await readPackageUp();
+ return param.reduce((res, key) => {
+ res[`project-${key}`] = global[key] || packageJson[key];
+ return res;
+ }, {});
+ } catch (e) {
+ return {};
+ }
+}
+
+/**
+ * Merge a configuration file into program config, assuming that the location
+ * of the configuration file is given as one of those config.
+ *
+ * @param {String} config the user-provided config path, usually via argv
+ * @returns {Promise} configuration, which are parsed
+ * @throws {Error} if the file cannot be read.
+ */
+async function readConfigFile(config) {
+ if (typeof config !== 'string') {
+ return {};
+ }
+ const filePath = config;
+ const absFilePath = path.resolve(process.cwd(), filePath);
+ const rawFile = await pify(fs).readFile(absFilePath, 'utf8');
+ const basePath = path.dirname(absFilePath);
+
+ let obj = null;
+ if (path.extname(filePath) === '.json') {
+ obj = JSON.parse(stripComments(rawFile));
+ } else {
+ obj = yaml.load(rawFile);
+ }
+ if ('noPackage' in obj) {
+ obj['no-package'] = obj.noPackage;
+ delete obj.noPackage;
+ }
+ return normalizeToc(obj, basePath);
+}
+
+export default async function mergeConfig(config = {}) {
+ conf.add(config);
+ conf.add(await readConfigFile(conf.globalConfig.config));
+ conf.add(await readPackage(conf.globalConfig['no-package']));
+
+ return conf.globalConfig;
+}
diff --git a/src/module_filters.js b/src/module_filters.js
new file mode 100644
index 000000000..59cc92d50
--- /dev/null
+++ b/src/module_filters.js
@@ -0,0 +1,11 @@
+// Skip external modules. Based on http://git.io/pzPO.
+const internalModuleRegexp =
+ process.platform === 'win32'
+ ? /* istanbul ignore next */
+ /^(\.|\w:)/
+ : /^[/.]/;
+
+/**
+ * Module filters
+ */
+export default id => internalModuleRegexp.test(id);
diff --git a/src/nest.js b/src/nest.js
new file mode 100644
index 000000000..e8471c376
--- /dev/null
+++ b/src/nest.js
@@ -0,0 +1,102 @@
+import _ from 'lodash';
+
+const PATH_SPLIT = /(?:\[])?\./g;
+
+function removeUnnamedTags(tags) {
+ return tags.filter(tag => typeof tag.name === 'string');
+}
+
+const tagDepth = tag => tag.name.split(PATH_SPLIT).length;
+
+/**
+ * Nest nestable tags, like param and property, into nested
+ * arrays that are suitable for output.
+ * Okay, so we're building a tree of comments, with the tag.name
+ * being the indexer. We sort by depth, so that we add each
+ * level of the tree incrementally, and throw if we run against
+ * a node that doesn't have a parent.
+ *
+ * foo.abe
+ * foo.bar.baz
+ * foo.bar.a
+ * foo.bar[].bax
+ *
+ * foo -> .abe
+ * \-> .bar -> .baz
+ * \-> .a
+ * \-> [].baz
+ *
+ * @private
+ * @param {Array} tags a list of tags
+ * @returns {Object} nested comment
+ */
+export const nestTag = (
+ tags,
+ errors
+ // Use lodash here both for brevity and also because, unlike JavaScript's
+ // sort, it's stable.
+) =>
+ _.sortBy(removeUnnamedTags(tags), tagDepth).reduce(
+ (memo, tag) => {
+ function insertTag(node, parts) {
+ // The 'done' case: we're at parts.length === 1,
+ // this is where the node should be placed. We reliably
+ // get to this case because the recursive method
+ // is always passed parts.slice(1)
+ if (parts.length === 1) {
+ Object.assign(node, {
+ properties: (node.properties || []).concat(tag)
+ });
+ } else {
+ // The recursive case: try to find the child that owns
+ // this tag.
+ const child =
+ node.properties &&
+ node.properties.find(
+ property => parts[0] === _.last(property.name.split(PATH_SPLIT))
+ );
+
+ if (!child) {
+ if (tag.name.match(/^(\$\d+)/)) {
+ errors.push({
+ message:
+ `Parent of ${tag.name} not found. To document a destructuring\n` +
+ `type, add a @param tag in its position to specify the name of the\n` +
+ `destructured parameter`,
+ commentLineNumber: tag.lineNumber
+ });
+ } else {
+ errors.push({
+ message: `Parent of ${tag.name} not found`,
+ commentLineNumber: tag.lineNumber
+ });
+ }
+ } else {
+ insertTag(child, parts.slice(1));
+ }
+ }
+ }
+
+ insertTag(memo, tag.name.split(PATH_SPLIT));
+ return memo;
+ },
+ { properties: [] }
+ ).properties;
+
+/**
+ * Nests
+ * [parameters with properties](http://usejsdoc.org/tags-param.html#parameters-with-properties).
+ *
+ * A parameter `employee.name` will be attached to the parent parameter `employee` in
+ * a `properties` array.
+ *
+ * This assumes that incoming comments have been flattened.
+ *
+ * @param {Object} comment input comment
+ * @returns {Object} nested comment
+ */
+export const nest = comment =>
+ Object.assign(comment, {
+ params: nestTag(comment.params, comment.errors),
+ properties: nestTag(comment.properties, comment.errors)
+ });
diff --git a/lib/output/highlighter.js b/src/output/highlighter.js
similarity index 57%
rename from lib/output/highlighter.js
rename to src/output/highlighter.js
index 69caabfe4..4d43d52b8 100644
--- a/lib/output/highlighter.js
+++ b/src/output/highlighter.js
@@ -1,5 +1,5 @@
-var visit = require('unist-util-visit');
-var hljs = require('highlight.js');
+import { visit } from 'unist-util-visit';
+import hljs from 'highlight.js';
/**
* Adapted from remark-highlight.js
@@ -11,12 +11,14 @@ var hljs = require('highlight.js');
function visitor(node) {
if (node.lang) {
node.type = 'html';
- node.value = '' +
- hljs.highlightAuto(node.value, [node.lang]).value + ' ';
+ node.value =
+ "" +
+ hljs.highlightAuto(node.value, [node.lang]).value +
+ ' ';
}
}
-module.exports = function (ast) {
+export default function (ast) {
visit(ast, 'code', visitor);
return ast;
-};
+}
diff --git a/src/output/html.js b/src/output/html.js
new file mode 100644
index 000000000..34d004759
--- /dev/null
+++ b/src/output/html.js
@@ -0,0 +1,31 @@
+import path from 'path';
+import mergeConfig from '../merge_config.js';
+
+/**
+ * Formats documentation as HTML.
+ *
+ * @param {Array} comments parsed comments
+ * @param {Object} config Options that can customize the output
+ * @param {string} [config.theme='default_theme'] Name of a module used for an HTML theme.
+ * @returns {Promise>} Promise with results
+ * @name formats.html
+ * @public
+ * @example
+ * var documentation = require('documentation');
+ *
+ * documentation.build(['index.js'])
+ * .then(documentation.formats.html);
+ */
+export default async function html(comments, localConfig = {}) {
+ const config = await mergeConfig(localConfig);
+ let themePath = config.theme && path.resolve(process.cwd(), config.theme);
+ if (themePath) {
+ if (process.platform === 'win32'){
+ // On Windows, absolute paths must be prefixed with 'file:///' to avoid the ERR_UNSUPPORTED_ESM_URL_SCHEME error from import().
+ themePath = 'file:///' + themePath;
+ }
+
+ return (await import(themePath)).default(comments, config);
+ }
+ return (await import('../default_theme/index.js')).default(comments, config);
+}
diff --git a/src/output/json.js b/src/output/json.js
new file mode 100644
index 000000000..920c87514
--- /dev/null
+++ b/src/output/json.js
@@ -0,0 +1,30 @@
+import walk from '../walk.js';
+
+/**
+ * Formats documentation as a JSON string.
+ *
+ * @param {Array} comments parsed comments
+ * @returns {Promise}
+ * @name formats.json
+ * @public
+ * @example
+ * var documentation = require('documentation');
+ * var fs = require('fs');
+ *
+ * documentation.build(['index.js'])
+ * .then(documentation.formats.json)
+ * .then(output => {
+ * // output is a string of JSON data
+ * fs.writeFileSync('./output.json', output);
+ * });
+ */
+export default function json(comments) {
+ walk(comments, comment => {
+ delete comment.errors;
+ if (comment.context) {
+ delete comment.context.sortKey;
+ }
+ });
+
+ return Promise.resolve(JSON.stringify(comments, null, 2));
+}
diff --git a/src/output/markdown.js b/src/output/markdown.js
new file mode 100644
index 000000000..b7a76566c
--- /dev/null
+++ b/src/output/markdown.js
@@ -0,0 +1,32 @@
+import { remark } from 'remark';
+import remarkGfm from 'remark-gfm';
+import markdownAST from './markdown_ast.js';
+
+/**
+ * Formats documentation as
+ * [Markdown](https://daringfireball.net/projects/markdown/).
+ *
+ * @param {Array} comments parsed comments
+ * @param {Object} args Options that can customize the output
+ * @name formats.markdown
+ * @returns {Promise} a promise of the eventual value
+ * @public
+ * @example
+ * var documentation = require('documentation');
+ * var fs = require('fs');
+ *
+ * documentation.build(['index.js'])
+ * .then(documentation.formats.md)
+ * .then(output => {
+ * // output is a string of Markdown data
+ * fs.writeFileSync('./output.md', output);
+ * });
+ */
+export default function markdown(comments, args) {
+ if (!args) {
+ args = {};
+ }
+ return markdownAST(comments, args).then(ast =>
+ remark().use(remarkGfm).stringify(ast)
+ );
+}
diff --git a/src/output/markdown_ast.js b/src/output/markdown_ast.js
new file mode 100644
index 000000000..09ca97fe6
--- /dev/null
+++ b/src/output/markdown_ast.js
@@ -0,0 +1,395 @@
+import { u } from 'unist-builder';
+import { remark } from 'remark';
+import mergeConfig from '../merge_config.js';
+import toc from 'remark-toc';
+import links from 'remark-reference-links';
+import hljs from 'highlight.js';
+import GithubSlugger from 'github-slugger';
+import LinkerStack from './util/linker_stack.js';
+import rerouteLinks from './util/reroute_links.js';
+import _formatType from './util/format_type.js';
+
+const DEFAULT_LANGUAGE = 'javascript';
+
+/**
+ * Given a hierarchy-nested set of comments, generate an remark-compatible
+ * Abstract Syntax Tree usable for generating Markdown output
+ *
+ * @param comments nested comment
+ * @param {Object} args currently none accepted
+ * @param {boolean} [args.markdownToc=true] whether to include a table of contents
+ * in markdown output.
+ * @param {Object} [args.hljs={}] config to be passed to highlightjs for code highlighting:
+ * consult hljs.configure for the full list.
+ * @returns {Promise} returns an eventual Markdown value
+ */
+export default function markdownAST(comments, args) {
+ return mergeConfig(args).then(config => buildMarkdownAST(comments, config));
+}
+
+function buildMarkdownAST(comments, config) {
+ // Configure code highlighting
+ const hljsOptions = config.hljs || {};
+ hljs.configure(hljsOptions);
+
+ const linkerStack = new LinkerStack(config).namespaceResolver(
+ comments,
+ namespace => {
+ const slugger = new GithubSlugger();
+ return '#' + slugger.slug(namespace);
+ }
+ );
+
+ const formatType = _formatType.bind(undefined, linkerStack.link);
+
+ const generatorComment = [
+ u(
+ 'html',
+ ''
+ )
+ ];
+
+ const tableOfContentsHeading = [
+ u('heading', { depth: 3 }, [u('text', 'Table of Contents')])
+ ];
+
+ /**
+ * Generate an AST chunk for a comment at a given depth: this is
+ * split from the main function to handle hierarchically nested comments
+ *
+ * @param {number} depth nesting of the comment, starting at 1
+ * @param {Object} comment a single comment
+ * @returns {Object} remark-compatible AST
+ */
+ function generate(depth, comment) {
+ function typeSection(comment) {
+ return (
+ comment.type &&
+ u('paragraph', [u('text', 'Type: ')].concat(formatType(comment.type)))
+ );
+ }
+
+ function paramList(params) {
+ if (params.length === 0) return [];
+ return u(
+ 'list',
+ { ordered: false, spread: false },
+ params.map(param =>
+ u(
+ 'listItem',
+ [
+ u(
+ 'paragraph',
+ [
+ u('inlineCode', param.name),
+ u('text', ' '),
+ !!param.type && u('strong', formatType(param.type)),
+ u('text', ' ')
+ ]
+ .concat(param.description ? param.description.children : [])
+ .concat([
+ !!param.default &&
+ u('paragraph', [
+ u('text', ' (optional, default '),
+ u('inlineCode', param.default),
+ u('text', ')')
+ ])
+ ])
+ .filter(Boolean)
+ )
+ ]
+ .concat(param.properties && paramList(param.properties))
+ .filter(Boolean)
+ )
+ )
+ );
+ }
+
+ function paramSection(comment) {
+ return (
+ comment.params.length > 0 && [
+ u('heading', { depth: depth + 1 }, [u('text', 'Parameters')]),
+ paramList(comment.params)
+ ]
+ );
+ }
+
+ function propertySection(comment) {
+ return (
+ comment.properties.length > 0 && [
+ u('heading', { depth: depth + 1 }, [u('text', 'Properties')]),
+ propertyList(comment.properties)
+ ]
+ );
+ }
+
+ function propertyList(properties) {
+ return u(
+ 'list',
+ { ordered: false, spread: false },
+ properties.map(property =>
+ u(
+ 'listItem',
+ [
+ u(
+ 'paragraph',
+ [
+ u('inlineCode', property.name),
+ u('text', ' '),
+ u('strong', formatType(property.type)),
+ u('text', ' ')
+ ]
+ .concat(
+ property.description ? property.description.children : []
+ )
+ .filter(Boolean)
+ ),
+ property.properties && propertyList(property.properties)
+ ].filter(Boolean)
+ )
+ )
+ );
+ }
+
+ function examplesSection(comment) {
+ return (
+ comment.examples.length > 0 &&
+ [u('heading', { depth: depth + 1 }, [u('text', 'Examples')])].concat(
+ comment.examples.reduce(function (memo, example) {
+ const language = hljsOptions.highlightAuto
+ ? hljs.highlightAuto(example.description).language
+ : DEFAULT_LANGUAGE;
+ return memo
+ .concat(
+ example.caption
+ ? [u('paragraph', [u('emphasis', example.caption)])]
+ : []
+ )
+ .concat([u('code', { lang: language }, example.description)]);
+ }, [])
+ )
+ );
+ }
+
+ function returnsSection(comment) {
+ return (
+ comment.returns.length > 0 &&
+ comment.returns.map(returns =>
+ u(
+ 'paragraph',
+ [
+ u('text', 'Returns '),
+ u('strong', formatType(returns.type)),
+ u('text', ' ')
+ ].concat(returns.description ? returns.description.children : [])
+ )
+ )
+ );
+ }
+
+ function throwsSection(comment) {
+ return (
+ comment.throws.length > 0 &&
+ u(
+ 'list',
+ { ordered: false, spread: false },
+ comment.throws.map(returns =>
+ u('listItem', [
+ u(
+ 'paragraph',
+ [
+ u('text', 'Throws '),
+ u('strong', formatType(returns.type)),
+ u('text', ' ')
+ ].concat(
+ returns.description ? returns.description.children : []
+ )
+ )
+ ])
+ )
+ )
+ );
+ }
+
+ function augmentsLink(comment) {
+ return (
+ comment.augments.length > 0 &&
+ u('paragraph', [
+ u('strong', [
+ u('text', 'Extends '),
+ u('text', comment.augments.map(tag => tag.name).join(', '))
+ ])
+ ])
+ );
+ }
+
+ function seeLink({ sees = [] }) {
+ return (
+ sees.length > 0 &&
+ u(
+ 'list',
+ { ordered: false, spread: false },
+ sees.map(see =>
+ u('listItem', [
+ u(
+ 'paragraph',
+ [u('strong', [u('text', 'See')]), u('text', ': ')].concat(
+ see.description
+ )
+ )
+ ])
+ )
+ )
+ );
+ }
+
+ function githubLink(comment) {
+ return (
+ comment.context &&
+ comment.context.github &&
+ u('paragraph', [
+ u(
+ 'link',
+ {
+ title: 'Source code on GitHub',
+ url: comment.context.github.url
+ },
+ [
+ u(
+ 'text',
+ comment.context.github.path +
+ ':' +
+ comment.context.loc.start.line +
+ '-' +
+ comment.context.loc.end.line
+ )
+ ]
+ )
+ ])
+ );
+ }
+
+ function metaSection(comment) {
+ const meta = [
+ 'version',
+ 'since',
+ 'copyright',
+ 'author',
+ 'license',
+ 'deprecated'
+ ].filter(tag => comment[tag]);
+ return (
+ !!meta.length &&
+ [u('strong', [u('text', 'Meta')])].concat(
+ u(
+ 'list',
+ { ordered: false, spread: false },
+ meta.map(tag => {
+ let metaContent;
+ if (tag === 'copyright' || tag === 'deprecated') {
+ metaContent = comment[tag];
+ } else {
+ metaContent = u('text', comment[tag]);
+ }
+ return u('listItem', [
+ u('paragraph', [
+ u('strong', [u('text', tag)]),
+ u('text', ': '),
+ metaContent
+ ])
+ ]);
+ })
+ )
+ )
+ );
+ }
+
+ if (comment.kind === 'note') {
+ return [u('heading', { depth }, [u('text', comment.name || '')])]
+ .concat(comment.description)
+ .concat(
+ !!comment.members.static.length &&
+ comment.members.static.reduce(
+ (memo, child) => memo.concat(generate(depth + 1, child)),
+ []
+ )
+ )
+ .filter(Boolean);
+ }
+
+ return [u('heading', { depth }, [u('text', comment.name || '')])]
+ .concat(githubLink(comment))
+ .concat(augmentsLink(comment))
+ .concat(seeLink(comment))
+ .concat(comment.description ? comment.description.children : [])
+ .concat(typeSection(comment))
+ .concat(paramSection(comment))
+ .concat(propertySection(comment))
+ .concat(examplesSection(comment))
+ .concat(throwsSection(comment))
+ .concat(returnsSection(comment))
+ .concat(metaSection(comment))
+ .concat(
+ !!comment.members.global.length &&
+ comment.members.global.reduce(
+ (memo, child) => memo.concat(generate(depth + 1, child)),
+ []
+ )
+ )
+ .concat(
+ !!comment.members.instance.length &&
+ comment.members.instance.reduce(
+ (memo, child) => memo.concat(generate(depth + 1, child)),
+ []
+ )
+ )
+ .concat(
+ !!comment.members.static.length &&
+ comment.members.static.reduce(
+ (memo, child) => memo.concat(generate(depth + 1, child)),
+ []
+ )
+ )
+ .concat(
+ !!comment.members.inner.length &&
+ comment.members.inner.reduce(
+ (memo, child) => memo.concat(generate(depth + 1, child)),
+ []
+ )
+ )
+ .concat(
+ !!comment.members.events.length &&
+ comment.members.events.reduce(
+ (memo, child) => memo.concat(generate(depth + 1, child)),
+ []
+ )
+ )
+ .filter(Boolean);
+ }
+
+ let root = rerouteLinks(
+ linkerStack.link,
+ u(
+ 'root',
+ generatorComment
+ .concat(config.markdownToc ? tableOfContentsHeading : [])
+ .concat(
+ comments.reduce(
+ (memo, comment) => memo.concat(generate(2, comment)),
+ []
+ )
+ )
+ )
+ );
+
+ const pluginRemark = remark();
+ if (config.markdownToc)
+ pluginRemark.use(toc, {
+ tight: true,
+ maxDepth: config.markdownTocMaxDepth
+ });
+ if (config.noReferenceLinks !== true) pluginRemark.use(links);
+ root = pluginRemark.run(root);
+
+ return Promise.resolve(root);
+}
diff --git a/lib/output/util/format_type.js b/src/output/util/format_type.js
similarity index 50%
rename from lib/output/util/format_type.js
rename to src/output/util/format_type.js
index ff7b47302..d66e03678 100644
--- a/lib/output/util/format_type.js
+++ b/src/output/util/format_type.js
@@ -1,5 +1,6 @@
-var Syntax = require('doctrine').Syntax,
- u = require('unist-builder');
+import doctrine from 'doctrine-temporary-fork';
+const Syntax = doctrine.Syntax;
+import { u } from 'unist-builder';
/**
* Shortcut to create a new text node
@@ -25,15 +26,19 @@ function t(text) {
* link('string').url // => 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String'
*/
function link(text, getHref, description) {
- var href = getHref(text);
+ const href = getHref(text);
if (href) {
// TODO: this is a temporary fix until we drop remark 3.x support,
// and then we should remove the 'href' property and only
// have the url property of links
- return u('link', {
- href: href,
- url: href
- }, [t(description || text)]);
+ return u(
+ 'link',
+ {
+ href,
+ url: href
+ },
+ [t(description || text)]
+ );
}
return t(text);
}
@@ -52,11 +57,11 @@ function link(text, getHref, description) {
* @returns {Array} formatted remark AST
*/
function commaList(getHref, items, start, end, sep) {
- var res = [];
+ let res = [];
if (start) {
res.push(t(start));
}
- for (var i = 0, iz = items.length; i < iz; ++i) {
+ for (let i = 0, iz = items.length; i < iz; ++i) {
res = res.concat(formatType(getHref, items[i]));
if (i + 1 !== iz) {
res.push(t(sep || ', '));
@@ -95,92 +100,97 @@ function decorate(formatted, str, prefix) {
* formatType({ type: 'NameExpression', name: 'String' })[0].url
* // => 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String'
*/
-function formatType(getHref, node) {
- var result = [];
+export default function formatType(getHref, node) {
+ let result = [];
if (!node) {
return [t('any')];
}
switch (node.type) {
- case Syntax.NullableLiteral:
- return [t('?')];
- case Syntax.AllLiteral:
- return [t('any')];
- case Syntax.NullLiteral:
- return [t('null')];
- case Syntax.VoidLiteral:
- return [t('void')];
- case Syntax.UndefinedLiteral:
- return [link('undefined', getHref)];
- case Syntax.NameExpression:
- return [link(node.name, getHref)];
- case Syntax.ParameterType:
- return [t(node.name + ': ')].concat(formatType(getHref, node.expression));
-
- case Syntax.TypeApplication:
- return formatType(getHref, node.expression)
- .concat(commaList(getHref, node.applications, '<', '>'));
- case Syntax.UnionType:
- return commaList(getHref, node.elements, '(', ')', ' | ');
- case Syntax.ArrayType:
- return commaList(getHref, node.elements, '[', ']');
- case Syntax.RecordType:
- return commaList(getHref, node.fields, '{', '}');
-
- case Syntax.FieldType:
- if (node.value) {
- return [t(node.key + ': ')].concat(formatType(getHref, node.value));
- }
- return [t(node.key)];
+ case Syntax.NullableLiteral:
+ return [t('?')];
+ case Syntax.AllLiteral:
+ return [t('any')];
+ case Syntax.NullLiteral:
+ return [t('null')];
+ case Syntax.VoidLiteral:
+ return [t('void')];
+ case Syntax.UndefinedLiteral:
+ return [link('undefined', getHref)];
+ case Syntax.NameExpression:
+ return [link(node.name, getHref)];
+ case Syntax.ParameterType:
+ if (node.name) {
+ result.push(t(node.name + ': '));
+ }
+ return result.concat(formatType(getHref, node.expression));
+
+ case Syntax.TypeApplication:
+ return formatType(getHref, node.expression).concat(
+ commaList(getHref, node.applications, '<', '>')
+ );
+ case Syntax.UnionType:
+ return commaList(getHref, node.elements, '(', ')', ' | ');
+ case Syntax.ArrayType:
+ return commaList(getHref, node.elements, '[', ']');
+ case Syntax.RecordType:
+ return commaList(getHref, node.fields, '{', '}');
+
+ case Syntax.FieldType:
+ if (node.value) {
+ return [t(node.key + ': ')].concat(formatType(getHref, node.value));
+ }
+ return [t(node.key)];
- case Syntax.FunctionType:
- result = [t('function (')];
+ case Syntax.FunctionType:
+ result = [t('function (')];
- if (node['this']) {
- if (node['new']) {
- result.push(t('new: '));
- } else {
- result.push(t('this: '));
- }
+ if (node['this']) {
+ if (node['new']) {
+ result.push(t('new: '));
+ } else {
+ result.push(t('this: '));
+ }
- result = result.concat(formatType(getHref, node['this']));
+ result = result.concat(formatType(getHref, node['this']));
- if (node.params.length !== 0) {
- result.push(t(', '));
+ if (node.params.length !== 0) {
+ result.push(t(', '));
+ }
}
- }
- result = result.concat(commaList(getHref, node.params, '', ')'));
+ result = result.concat(commaList(getHref, node.params, '', ')'));
- if (node.result) {
- result = result.concat([t(': ')].concat(formatType(getHref, node.result)));
- }
- return result;
-
- case Syntax.RestType:
- // note that here we diverge from doctrine itself, which
- // lets the expression be omitted.
- return decorate(formatType(getHref, node.expression), '...', true);
- case Syntax.OptionalType:
- if (node.default) {
- return decorate(formatType(getHref, node.expression), '?')
- .concat(t('= ' + node.default));
- }
- return decorate(formatType(getHref, node.expression), '?');
- case Syntax.NonNullableType:
- return decorate(formatType(getHref, node.expression), '!', node.prefix);
- case Syntax.NullableType:
- return decorate(formatType(getHref, node.expression), '?');
- case Syntax.StringLiteralType:
- return [u('inlineCode', JSON.stringify(node.value))];
- case Syntax.NumericLiteralType:
- case Syntax.BooleanLiteralType:
- return [u('inlineCode', String(node.value))];
-
- default:
- throw new Error('Unknown type ' + node.type);
+ if (node.result) {
+ result = result.concat(
+ [t(': ')].concat(formatType(getHref, node.result))
+ );
+ }
+ return result;
+
+ case Syntax.RestType:
+ // note that here we diverge from doctrine itself, which
+ // lets the expression be omitted.
+ return decorate(formatType(getHref, node.expression), '...', true);
+ case Syntax.OptionalType:
+ if (node.default) {
+ return decorate(formatType(getHref, node.expression), '?').concat(
+ t('= ' + node.default)
+ );
+ }
+ return decorate(formatType(getHref, node.expression), '?');
+ case Syntax.NonNullableType:
+ return decorate(formatType(getHref, node.expression), '!', node.prefix);
+ case Syntax.NullableType:
+ return decorate(formatType(getHref, node.expression), '?');
+ case Syntax.StringLiteralType:
+ return [u('inlineCode', JSON.stringify(node.value))];
+ case Syntax.NumericLiteralType:
+ case Syntax.BooleanLiteralType:
+ return [u('inlineCode', String(node.value))];
+
+ default:
+ throw new Error('Unknown type ' + node.type);
}
}
-
-module.exports = formatType;
diff --git a/lib/output/util/formatters.js b/src/output/util/formatters.js
similarity index 68%
rename from lib/output/util/formatters.js
rename to src/output/util/formatters.js
index d2cb1b036..15ab86e6f 100644
--- a/lib/output/util/formatters.js
+++ b/src/output/util/formatters.js
@@ -1,22 +1,23 @@
-var remark = require('remark'),
- html = require('remark-html'),
- Syntax = require('doctrine').Syntax,
- u = require('unist-builder'),
- _rerouteLinks = require('./reroute_links'),
- highlighter = require('../highlighter'),
- formatType = require('./format_type');
+import { remark } from 'remark';
+import html from 'remark-html';
+import doctrine from 'doctrine-temporary-fork';
+const Syntax = doctrine.Syntax;
+import { u } from 'unist-builder';
+import _rerouteLinks from './reroute_links.js';
+import highlighter from '../highlighter.js';
+import formatType from './format_type.js';
/**
* Create a formatter group, given a linker method that resolves
* namespaces to URLs
*
- * @param {Function} getHref linker method
+ * @param getHref linker method
* @returns {formatters} formatter object
*/
-module.exports = function (getHref) {
- var rerouteLinks = _rerouteLinks.bind(undefined, getHref);
+export default function (getHref) {
+ const rerouteLinks = _rerouteLinks.bind(undefined, getHref);
- var formatters = {};
+ const formatters = {};
/**
* Format a parameter name. This is used in formatParameters
@@ -51,6 +52,7 @@ module.exports = function (getHref) {
.use(html)
.stringify(highlighter(rerouteLinks(ast)));
}
+ return '';
};
/**
@@ -60,25 +62,34 @@ module.exports = function (getHref) {
* @returns {string} HTML
*/
formatters.type = function (type) {
- return formatters.markdown(u('root', formatType(getHref, type))).replace(/\n/g, '');
+ return formatters
+ .markdown(u('root', formatType(getHref, type)))
+ .replace(/\n/g, '');
};
/**
* Link text to this page or to a central resource.
* @param {string} text inner text of the link
- * @param {string} description link text override
* @returns {string} potentially linked HTML
*/
formatters.autolink = function (text) {
- var href = getHref(text);
+ const href = getHref(text);
if (href) {
// TODO: this is a temporary fix until we drop remark 3.x support,
// and then we should remove the 'href' property and only
// have the url property of links
- return formatters.markdown(u('link', {
- href: href,
- url: href
- }, [u('text', text)])).replace(/\n/g, '');
+ return formatters
+ .markdown(
+ u(
+ 'link',
+ {
+ href,
+ url: href
+ },
+ [u('text', text)]
+ )
+ )
+ .replace(/\n/g, '');
}
return formatters.markdown(u('text', text)).replace(/\n/g, '');
};
@@ -94,12 +105,18 @@ module.exports = function (getHref) {
*/
formatters.parameters = function (section, short) {
if (section.params) {
- return '(' + section.params.map(function (param) {
- return formatters.parameter(param, short);
- }).join(', ') + ')';
+ return (
+ '(' +
+ section.params
+ .map(function (param) {
+ return formatters.parameter(param, short);
+ })
+ .join(', ') +
+ ')'
+ );
}
return '()';
};
return formatters;
-};
+}
diff --git a/src/output/util/linker_stack.js b/src/output/util/linker_stack.js
new file mode 100644
index 000000000..10c731838
--- /dev/null
+++ b/src/output/util/linker_stack.js
@@ -0,0 +1,108 @@
+import globalsDocs from 'globals-docs';
+import walk from '../../walk.js';
+
+/**
+ * Generate a linker method that links given hardcoded namepaths to URLs
+ *
+ * @param {Object} paths an object specified in documentation.yml of hard paths
+ * @returns {Function} linker
+ */
+function pathsLinker(paths /* Object */) {
+ return function (namespace) {
+ if (paths[namespace]) {
+ return paths[namespace];
+ }
+ };
+}
+
+/**
+ * Given an array of functions, call each of them with `input`
+ * and return the output of the first one that returns a truthy value.
+ *
+ * @param {Array} fns array of methods
+ * @param {*} input any input
+ * @returns {*} any output
+ */
+function firstPass(fns, input) {
+ for (let i = 0; i < fns.length; i++) {
+ const output = fns[i](input);
+ if (output) {
+ return output;
+ }
+ }
+}
+
+/**
+ * Create a linking method that takes a namepath and returns a URI
+ * or a falsy value
+ *
+ * @param {Object} config - configuration value
+ * @returns {Function} linker method
+ */
+export default class LinkerStack {
+ constructor(config) {
+ this.stack = [];
+
+ if (config.defaultGlobals !== false) {
+ this.stack.unshift(namespace => {
+ if (namespace) {
+ return globalsDocs.getDoc(namespace, config.defaultGlobalsEnvs);
+ }
+ });
+ }
+
+ if (config.paths) {
+ this.stack.unshift(pathsLinker(config.paths));
+ }
+
+ this.link = this._link.bind(this);
+ }
+
+ /**
+ * Given that the linker stack is a stack of functions, each of which might
+ * be able to resolve the URL target of a given namespace, namespaceResolver
+ * adds a function to the stack. You give it a list of comments and it
+ * adds a function that, if it matches a namespace to a comment, runs
+ * `resolver` on that comment's namespace in order to get a URL. This makes
+ * it possible for themes to put each function on a separate page, or at
+ * different anchors on the same page, and the resolver does stuff like
+ * adding '#' in front of the namespace or turning the namespace into a URL
+ * path.
+ *
+ * @param {Array} comments a list of comments
+ * @param {Function} resolver a method that turns a namespace into a URL
+ * @returns {LinkerStack} returns this
+ * @private
+ * @example
+ * var linkerStack = new LinkerStack(options)
+ * .namespaceResolver(comments, function (namespace) {
+ * var slugger = new GithubSlugger();
+ * return '#' + slugger.slug(namespace);
+ * });
+ */
+ namespaceResolver(comments, resolver) {
+ const namespaces = {};
+ walk(comments, comment => {
+ namespaces[comment.namespace] = true;
+ });
+ this.stack.unshift(namespace => {
+ if (namespaces[namespace] === true) {
+ return resolver(namespace);
+ }
+ });
+ return this;
+ }
+
+ /**
+ * Now that you've configured the LinkerStack with `namespaceResolver`
+ * and a configuration, run it against a namepath. Might return a URL if
+ * it can resolve a target, otherwise returns undefined.
+ *
+ * @param {string} namepath the namepath of a comment
+ * @returns {string?} URL target or maybe undefined
+ * @private
+ */
+ _link(namepath) {
+ return firstPass(this.stack, namepath);
+ }
+}
diff --git a/src/output/util/reroute_links.js b/src/output/util/reroute_links.js
new file mode 100644
index 000000000..cedb07b5b
--- /dev/null
+++ b/src/output/util/reroute_links.js
@@ -0,0 +1,21 @@
+import { visit } from 'unist-util-visit';
+
+/**
+ * Reroute inline jsdoc links in documentation
+ * @param getHref a method that resolves namespaces
+ * @param ast remark AST
+ * @returns {Object} that ast with rerouted links
+ * @private
+ */
+export default function rerouteLinks(getHref, ast) {
+ visit(ast, 'link', function (node) {
+ if (
+ node.jsdoc &&
+ !node.url.match(/^(http|https|\.)/) &&
+ getHref(node.url)
+ ) {
+ node.url = getHref(node.url);
+ }
+ });
+ return ast;
+}
diff --git a/lib/parse.js b/src/parse.js
similarity index 70%
rename from lib/parse.js
rename to src/parse.js
index f74306630..a10c7b2b8 100644
--- a/lib/parse.js
+++ b/src/parse.js
@@ -1,7 +1,5 @@
-'use strict';
-
-var doctrine = require('doctrine');
-var parseMarkdown = require('./parse_markdown');
+import doctrine from 'doctrine-temporary-fork';
+import parseMarkdown from './remark-parse.js';
/**
* Flatteners: these methods simplify the structure of JSDoc comments
@@ -9,8 +7,8 @@ var parseMarkdown = require('./parse_markdown');
* information where appropriate.
* @private
*/
-var flatteners = {
- 'abstract': flattenBoolean,
+const flatteners = {
+ abstract: flattenBoolean,
/**
* Parse tag
* @private
@@ -18,12 +16,14 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'access': function (result, tag) {
+ access(result, tag) {
+ // doctrine ensures that tag.access is valid
result.access = tag.access;
},
- 'alias': flattenName,
- 'arg': synonym('param'),
- 'argument': synonym('param'),
+ alias: flattenName,
+ arg: synonym('param'),
+ argument: synonym('param'),
+ async: flattenBoolean,
/**
* Parse tag
* @private
@@ -31,10 +31,7 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'augments': function (result, tag) {
- if (!result.augments) {
- result.augments = [];
- }
+ augments(result, tag) {
// Google variation of augments/extends tag:
// uses type with brackets instead of name.
// https://github.com/google/closure-library/issues/746
@@ -42,13 +39,13 @@ var flatteners = {
tag.name = tag.type.name;
}
if (!tag.name) {
- console.error('@extends from complex types is not supported yet'); // eslint-disable-line no-console
+ console.error('@extends from complex types is not supported yet'); // eslint-disable-line no-console
return;
}
result.augments.push(tag);
},
- 'author': flattenDescription,
- 'borrows': todo,
+ author: flattenDescription,
+ borrows: todo,
/**
* Parse tag
* @private
@@ -56,7 +53,7 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'callback': function (result, tag) {
+ callback(result, tag) {
result.kind = 'typedef';
if (tag.description) {
@@ -68,20 +65,27 @@ var flatteners = {
name: 'Function'
};
},
- 'class': flattenKindShorthand,
- 'classdesc': flattenMarkdownDescription,
- 'const': synonym('constant'),
- 'constant': flattenKindShorthand,
- 'constructor': synonym('class'),
- 'constructs': todo,
- 'copyright': flattenMarkdownDescription,
- 'default': todo,
- 'defaultvalue': synonym('default'),
- 'deprecated': flattenMarkdownDescription,
- 'desc': synonym('description'),
- 'description': flattenMarkdownDescription,
- 'emits': synonym('fires'),
- 'enum': todo,
+ class: flattenKindShorthand,
+ classdesc: flattenMarkdownDescription,
+ const: synonym('constant'),
+ constant: flattenKindShorthand,
+ constructor: synonym('class'),
+ constructs: todo,
+ copyright: flattenMarkdownDescription,
+ default: todo,
+ defaultvalue: synonym('default'),
+ deprecated(result, tag) {
+ const description = tag.description || 'This is deprecated.';
+ result.deprecated = parseMarkdown(description);
+ },
+ flattenMarkdownDescription,
+ desc: synonym('description'),
+ description: flattenMarkdownDescription,
+ emits: synonym('fires'),
+ enum(result, tag) {
+ result.kind = 'enum';
+ result.type = tag.type;
+ },
/**
* Parse tag
* @private
@@ -89,7 +93,7 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'event': function (result, tag) {
+ event(result, tag) {
result.kind = 'event';
if (tag.description) {
@@ -103,7 +107,7 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'example': function (result, tag) {
+ example(result, tag) {
if (!tag.description) {
result.errors.push({
message: '@example without code',
@@ -112,11 +116,7 @@ var flatteners = {
return;
}
- if (!result.examples) {
- result.examples = [];
- }
-
- var example = {
+ const example = {
description: tag.description
};
@@ -126,9 +126,9 @@ var flatteners = {
result.examples.push(example);
},
- 'exception': synonym('throws'),
- 'exports': todo,
- 'extends': synonym('augments'),
+ exception: synonym('throws'),
+ exports: todo,
+ extends: synonym('augments'),
/**
* Parse tag
* @private
@@ -136,7 +136,7 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'external': function (result, tag) {
+ external(result, tag) {
result.kind = 'external';
if (tag.description) {
@@ -150,37 +150,46 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'file': function (result, tag) {
+ file(result, tag) {
result.kind = 'file';
if (tag.description) {
result.description = parseMarkdown(tag.description);
}
},
- 'fileoverview': synonym('file'),
- 'fires': todo,
- 'func': synonym('function'),
- 'function': flattenKindShorthand,
+ fileoverview: synonym('file'),
+ fires: todo,
+ func: synonym('function'),
+ function: flattenKindShorthand,
+ generator: flattenBoolean,
/**
* Parse tag
* @private
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'global': function (result) {
+ global(result) {
result.scope = 'global';
},
- 'host': synonym('external'),
- 'ignore': flattenBoolean,
- 'implements': todo,
- 'inheritdoc': todo,
+ hideconstructor: flattenBoolean,
+ host: synonym('external'),
+ ignore: flattenBoolean,
+ implements(result, tag) {
+ // Match @extends/@augments above.
+ if (!tag.name && tag.type && tag.type.name) {
+ tag.name = tag.type.name;
+ }
+
+ result.implements.push(tag);
+ },
+ inheritdoc: todo,
/**
* Parse tag
* @private
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'inner': function (result) {
+ inner(result) {
result.scope = 'inner';
},
/**
@@ -189,7 +198,7 @@ var flatteners = {
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'instance': function (result) {
+ instance(result) {
result.scope = 'instance';
},
/**
@@ -199,8 +208,8 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'interface': function (result, tag) {
- result.interface = true;
+ interface(result, tag) {
+ result.kind = 'interface';
if (tag.description) {
result.name = tag.description;
}
@@ -212,22 +221,23 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'kind': function (result, tag) {
+ kind(result, tag) {
+ // doctrine ensures that tag.kind is valid
result.kind = tag.kind;
},
- 'lends': flattenDescription,
- 'license': flattenDescription,
- 'listens': todo,
- 'member': flattenKindShorthand,
- 'memberof': flattenDescription,
- 'method': synonym('function'),
- 'mixes': todo,
- 'mixin': flattenKindShorthand,
- 'module': flattenKindShorthand,
- 'name': flattenName,
- 'namespace': flattenKindShorthand,
- 'override': flattenBoolean,
- 'overview': synonym('file'),
+ lends: flattenDescription,
+ license: flattenDescription,
+ listens: todo,
+ member: flattenKindShorthand,
+ memberof: flattenDescription,
+ method: synonym('function'),
+ mixes: todo,
+ mixin: flattenKindShorthand,
+ module: flattenKindShorthand,
+ name: flattenName,
+ namespace: flattenKindShorthand,
+ override: flattenBoolean,
+ overview: synonym('file'),
/**
* Parse tag
* @private
@@ -235,12 +245,9 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'param': function (result, tag) {
- if (!result.params) {
- result.params = [];
- }
-
- var param = {
+ param(result, tag) {
+ const param = {
+ title: 'param',
name: tag.name,
lineNumber: tag.lineNumber // TODO: remove
};
@@ -255,6 +262,9 @@ var flatteners = {
if (tag.default) {
param.default = tag.default;
+ if (param.type && param.type.type === 'OptionalType') {
+ param.type = param.type.expression;
+ }
}
result.params.push(param);
@@ -265,10 +275,10 @@ var flatteners = {
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'private': function (result) {
+ private(result) {
result.access = 'private';
},
- 'prop': synonym('property'),
+ prop: synonym('property'),
/**
* Parse tag
* @private
@@ -276,12 +286,9 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'property': function (result, tag) {
- if (!result.properties) {
- result.properties = [];
- }
-
- var property = {
+ property(result, tag) {
+ const property = {
+ title: 'property',
name: tag.name,
lineNumber: tag.lineNumber // TODO: remove
};
@@ -302,7 +309,7 @@ var flatteners = {
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'protected': function (result) {
+ protected(result) {
result.access = 'protected';
},
/**
@@ -311,12 +318,12 @@ var flatteners = {
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'public': function (result) {
+ public(result) {
result.access = 'public';
},
- 'readonly': flattenBoolean,
- 'requires': todo,
- 'return': synonym('returns'),
+ readonly: flattenBoolean,
+ requires: todo,
+ return: synonym('returns'),
/**
* Parse tag
* @private
@@ -324,13 +331,10 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'returns': function (result, tag) {
- if (!result.returns) {
- result.returns = [];
- }
-
- var returns = {
- description: parseMarkdown(tag.description)
+ returns(result, tag) {
+ const returns = {
+ description: parseMarkdown(tag.description),
+ title: 'returns'
};
if (tag.type) {
@@ -346,24 +350,30 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'see': function (result, tag) {
- if (!result.sees) {
- result.sees = [];
+ see(result, tag) {
+ const sees = {
+ description: parseMarkdown(tag.description),
+ title: 'sees'
+ };
+
+ if (tag.type) {
+ sees.type = tag.type;
}
- result.sees.push(parseMarkdown(tag.description));
+
+ result.sees.push(sees);
},
- 'since': flattenDescription,
+ since: flattenDescription,
/**
* Parse tag
* @private
* @param {Object} result target comment
* @returns {undefined} has side-effects
*/
- 'static': function (result) {
+ static(result) {
result.scope = 'static';
},
- 'summary': flattenMarkdownDescription,
- 'this': todo,
+ summary: flattenMarkdownDescription,
+ this: todo,
/**
* Parse tag
* @private
@@ -371,12 +381,8 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'throws': function (result, tag) {
- if (!result.throws) {
- result.throws = [];
- }
-
- var throws = {};
+ throws(result, tag) {
+ const throws = {};
if (tag.description) {
throws.description = parseMarkdown(tag.description);
@@ -395,16 +401,15 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'todo': function (result, tag) {
- if (!result.todos) {
- result.todos = [];
- }
+ todo(result, tag) {
result.todos.push(parseMarkdown(tag.description));
},
- 'tutorial': todo,
- 'type': todo,
- 'typedef': flattenKindShorthand,
- 'var': synonym('member'),
+ tutorial: todo,
+ type(result, tag) {
+ result.type = tag.type;
+ },
+ typedef: flattenKindShorthand,
+ var: synonym('member'),
/**
* Parse tag
* @private
@@ -412,11 +417,31 @@ var flatteners = {
* @param {Object} tag the tag
* @returns {undefined} has side-effects
*/
- 'variation': function (result, tag) {
+ variation(result, tag) {
result.variation = tag.variation;
},
- 'version': flattenDescription,
- 'virtual': synonym('abstract')
+ version: flattenDescription,
+ virtual: synonym('abstract'),
+ yield: synonym('yields'),
+ /**
+ * Parse tag
+ * @private
+ * @param {Object} result target comment
+ * @param {Object} tag the tag
+ * @returns {undefined} has side-effects
+ */
+ yields(result, tag) {
+ const yields = {
+ description: parseMarkdown(tag.description),
+ title: 'yields'
+ };
+
+ if (tag.type) {
+ yields.type = tag.type;
+ }
+
+ result.yields.push(yields);
+ }
};
/**
@@ -433,7 +458,8 @@ function todo() {}
*/
function synonym(key) {
return function (result, tag) {
- return flatteners[key](result, tag, key);
+ const fun = flatteners[key];
+ fun.apply(null, [result, tag, key].slice(0, fun.length));
};
}
@@ -461,7 +487,6 @@ function flattenName(result, tag, key) {
result[key] = tag.name;
}
-
/**
* Flatten a usable-once description tag into a key
* @private
@@ -581,11 +606,11 @@ function flattenKindShorthand(result, tag, key) {
* @param {string} comment input to be parsed
* @param {Object} loc location of the input
* @param {Object} context code context of the input
- * @return {Comment} an object conforming to the
+ * @returns {Comment} an object conforming to the
* [documentation schema](https://github.com/documentationjs/api-json)
*/
-function parseJSDoc(comment, loc, context) {
- var result = doctrine.parse(comment, {
+export default function parseJSDoc(comment, loc, context) {
+ const result = doctrine.parse(comment, {
// have doctrine itself remove the comment asterisks from content
unwrap: true,
// enable parsing of optional parameters in brackets, JSDoc3 style
@@ -598,16 +623,38 @@ function parseJSDoc(comment, loc, context) {
result.loc = loc;
result.context = context;
+
+ result.augments = [];
result.errors = [];
+ result.examples = [];
+ result.implements = [];
+ result.params = [];
+ result.properties = [];
+ result.returns = [];
+ result.sees = [];
+ result.throws = [];
+ result.todos = [];
+ result.yields = [];
if (result.description) {
result.description = parseMarkdown(result.description);
}
+ // Reject parameter tags without a parameter name
+ result.tags.filter(function (tag) {
+ if (tag.title === 'param' && tag.name === undefined) {
+ result.errors.push({
+ message: 'A @param tag without a parameter name was rejected'
+ });
+ return false;
+ }
+ return true;
+ });
+
result.tags.forEach(function (tag) {
if (tag.errors) {
- for (var j = 0; j < tag.errors.length; j++) {
- result.errors.push({message: tag.errors[j]});
+ for (let j = 0; j < tag.errors.length; j++) {
+ result.errors.push({ message: tag.errors[j] });
}
} else if (flatteners[tag.title]) {
flatteners[tag.title](result, tag, tag.title);
@@ -619,7 +666,11 @@ function parseJSDoc(comment, loc, context) {
}
});
+ // Using the @name tag, or any other tag that sets the name of a comment,
+ // disconnects the comment from its surrounding code.
+ if (context && result.name) {
+ delete context.ast;
+ }
+
return result;
}
-
-module.exports = parseJSDoc;
diff --git a/lib/parsers/README.md b/src/parsers/README.md
similarity index 100%
rename from lib/parsers/README.md
rename to src/parsers/README.md
diff --git a/src/parsers/javascript.js b/src/parsers/javascript.js
new file mode 100644
index 000000000..880af6547
--- /dev/null
+++ b/src/parsers/javascript.js
@@ -0,0 +1,117 @@
+import _ from 'lodash';
+import t from '@babel/types';
+import parse from '../parse.js';
+import walkComments from '../extractors/comments.js';
+import walkExported from '../extractors/exported.js';
+import util from 'util';
+import findTarget from '../infer/finders.js';
+import { parseToAst } from './parse_to_ast.js';
+
+const debuglog = util.debuglog('documentation');
+
+/**
+ * Receives a module-dep item,
+ * reads the file, parses the JavaScript, and parses the JSDoc.
+ *
+ * @param {Object} data a chunk of data provided by module-deps
+ * @param {Object} config config
+ * @returns {Array} an array of parsed comments
+ */
+export default function parseJavaScript(data, config) {
+ const visited = new Set();
+ const commentsByNode = new Map();
+
+ const ast = parseToAst(data.source, data.file);
+ const addComment = _addComment.bind(null, visited, commentsByNode);
+
+ const extensions = []
+ .concat(config.parseExtension, config.requireExtension)
+ .filter(Boolean);
+
+ return _.flatMap(
+ config.documentExported
+ ? [walkExported.bind(null, { extensions })]
+ : [
+ walkComments.bind(null, 'leadingComments', true),
+ walkComments.bind(null, 'innerComments', false),
+ walkComments.bind(null, 'trailingComments', false)
+ ],
+ fn => fn(ast, data, addComment)
+ ).filter(comment => comment && !comment.lends);
+}
+
+function _addComment(
+ visited,
+ commentsByNode,
+ data,
+ commentValue,
+ commentLoc,
+ path,
+ nodeLoc,
+ includeContext
+) {
+ // Avoid visiting the same comment twice as a leading
+ // and trailing node
+ const key =
+ data.file + ':' + commentLoc.start.line + ':' + commentLoc.start.column;
+ if (!visited.has(key)) {
+ visited.add(key);
+
+ const context /* : {
+ loc: Object,
+ file: string,
+ sortKey: string,
+ ast?: Object,
+ code?: string
+ }*/ = {
+ loc: nodeLoc,
+ file: data.file,
+ sortKey:
+ data.sortKey + ' ' + nodeLoc.start.line.toString().padStart(8, '0')
+ };
+
+ if (includeContext) {
+ // This is non-enumerable so that it doesn't get stringified in
+ // output; e.g. by the documentation binary.
+ Object.defineProperty(context, 'ast', {
+ configurable: true,
+ enumerable: false,
+ value: path
+ });
+
+ if (path.parentPath && path.parentPath.node) {
+ const parentNode = path.parentPath.node;
+ context.code = data.source.substring(parentNode.start, parentNode.end);
+ }
+ }
+ const comment = parse(commentValue, commentLoc, context);
+ if (includeContext) {
+ commentsByNode.set((findTarget(path) || path).node, comment);
+
+ if (t.isClassMethod(path) && path.node.kind === 'constructor') {
+ // #689
+ if (
+ comment.tags.some(
+ tag => tag.title !== 'param' && tag.title !== 'hideconstructor'
+ )
+ ) {
+ debuglog(
+ 'A constructor was documented explicitly: document along with the class instead'
+ );
+ }
+
+ const parentComment = commentsByNode.get(
+ path.parentPath.parentPath.node
+ );
+ if (parentComment) {
+ parentComment.constructorComment = comment;
+ return;
+ }
+ if (comment.hideconstructor) {
+ return;
+ }
+ }
+ }
+ return comment;
+ }
+}
diff --git a/src/parsers/parse_to_ast.js b/src/parsers/parse_to_ast.js
new file mode 100644
index 000000000..0eed35d0a
--- /dev/null
+++ b/src/parsers/parse_to_ast.js
@@ -0,0 +1,60 @@
+import babelParser from '@babel/parser';
+import path from 'path';
+
+const TYPESCRIPT_EXTS = {
+ '.ts': ['typescript'],
+ '.tsx': ['typescript', 'jsx']
+};
+
+// this list is roughly the same as the one in prettier
+// https://github.com/prettier/prettier/blob/24d39a906834cf449304dc684b280a5ca9a0a6d7/src/language-js/parser-babel.js#L23
+export const standardBabelParserPlugins = [
+ 'classPrivateMethods',
+ 'classPrivateProperties',
+ 'classProperties',
+ 'classStaticBlock',
+ 'decimal',
+ ['decorators', { decoratorsBeforeExport: false }],
+ 'doExpressions',
+ 'exportDefaultFrom',
+ 'functionBind',
+ 'functionSent',
+ 'importAssertions',
+ 'moduleBlocks',
+ 'moduleStringNames',
+ 'partialApplication',
+ ['pipelineOperator', { proposal: 'minimal' }],
+ 'privateIn',
+ ['recordAndTuple', { syntaxType: 'hash' }],
+ 'throwExpressions',
+ 'v8intrinsic'
+];
+
+function getParserOpts(file) {
+ return {
+ allowImportExportEverywhere: true,
+ sourceType: 'module',
+ plugins: [
+ ...standardBabelParserPlugins,
+ ...(TYPESCRIPT_EXTS[path.extname(file || '')] || ['flow', 'jsx'])
+ ]
+ };
+}
+
+/**
+ * Convert flow comment types into flow annotations so that
+ * they end up in the final AST. If the source does not contain
+ * a flow pragma, the code is returned verbatim.
+ * @param {*} source code with flow type comments
+ * @returns {string} code with flow annotations
+ */
+export function commentToFlow(source) {
+ if (!/@flow/.test(source)) return source;
+ return source
+ .replace(/\/\*::([^]+?)\*\//g, '$1')
+ .replace(/\/\*:\s*([^]+?)\s*\*\//g, ':$1');
+}
+
+export function parseToAst(source, file) {
+ return babelParser.parse(commentToFlow(source), getParserOpts(file));
+}
diff --git a/src/remark-jsDoc-link.js b/src/remark-jsDoc-link.js
new file mode 100644
index 000000000..dfbfd4200
--- /dev/null
+++ b/src/remark-jsDoc-link.js
@@ -0,0 +1,115 @@
+import { findAndReplace } from 'mdast-util-find-and-replace';
+import { markdownLineEnding } from 'micromark-util-character';
+
+const link = '@link';
+const tutorial = '@tutorial';
+
+function tokenizeJsDoclink(effects, ok, nok) {
+ let index = 0;
+ let focus = link;
+
+ function atext(code) {
+ if (index !== link.length) {
+ if (focus.charCodeAt(index) === code) {
+ effects.consume(code);
+ index++;
+ return atext;
+ } else if (tutorial.charCodeAt(index) === code) {
+ focus = tutorial;
+ }
+ return nok(code);
+ }
+ if (code === 125) {
+ effects.consume(code);
+ effects.exit('literalJsDoclink');
+ return ok(code);
+ }
+
+ if (markdownLineEnding(code)) {
+ return nok(code);
+ }
+
+ effects.consume(code);
+ return atext;
+ }
+
+ return function (code) {
+ effects.enter('literalJsDoclink');
+ effects.consume(code);
+ return atext;
+ };
+}
+
+const text = {};
+text[123] = {
+ tokenize: tokenizeJsDoclink,
+ previous(code) {
+ return code === null || code === 32 || markdownLineEnding(code);
+ }
+};
+
+const linkRegExp = /\{@link\s+(.+?)(?:[\s|](.*?))?\}/;
+const tutorialRegExp = /\{@tutorial\s+(.+?)(?:[\s|](.*?))?\}/;
+
+/**
+ * A remark plugin that installs
+ * for JSDoc inline `{@link}` and `{@tutorial}` tags.
+ *
+ * This does not handle the `[text]({@link url})` and `[text]({@tutorial url})` forms of these tags.
+ * That's a JSDoc misfeature; just use regular markdown syntax instead: `[text](url)`.
+ *
+ * @returns {Function}
+ */
+export default function () {
+ const data = this.data();
+ function replace(type) {
+ return (match, matchUrl, matchValue) => {
+ return {
+ type,
+ url: matchUrl,
+ title: null,
+ jsdoc: true,
+ children: [
+ {
+ type: 'text',
+ value: matchValue || matchUrl
+ }
+ ]
+ };
+ };
+ }
+
+ add('micromarkExtensions', { text });
+ add('fromMarkdownExtensions', {
+ transforms: [
+ function (markdownAST) {
+ return findAndReplace(markdownAST, [
+ [new RegExp(linkRegExp.source, 'g'), replace('link')],
+ [new RegExp(tutorialRegExp.source, 'g'), replace('tutorial')]
+ ]);
+ }
+ ],
+ enter: {
+ literalJsDoclink(token) {
+ const str = this.sliceSerialize(token);
+ let match = null;
+ if (str.startsWith('{@link')) {
+ match = linkRegExp.exec(str);
+ } else {
+ match = tutorialRegExp.exec(str);
+ }
+
+ this.enter(replace('link')(...match), token);
+ }
+ },
+ exit: {
+ literalJsDoclink(token) {
+ this.exit(token);
+ }
+ }
+ });
+ function add(field, value) {
+ if (data[field]) data[field].push(value);
+ else data[field] = [value];
+ }
+}
diff --git a/src/remark-parse.js b/src/remark-parse.js
new file mode 100644
index 000000000..79d643947
--- /dev/null
+++ b/src/remark-parse.js
@@ -0,0 +1,14 @@
+import { remark } from 'remark';
+import gfm from 'remark-gfm';
+import removePosition from './remark-remove-position.js';
+import jsDocLink from './remark-jsDoc-link.js';
+
+/**
+ * Parse a string of Markdown into a Remark
+ * abstract syntax tree.
+ *
+ * @param {string} string markdown text
+ * @returns {Object} abstract syntax tree
+ * @private
+ */
+export default remark().use([jsDocLink, gfm, removePosition]).parse;
diff --git a/src/remark-remove-position.js b/src/remark-remove-position.js
new file mode 100644
index 000000000..fca981a64
--- /dev/null
+++ b/src/remark-remove-position.js
@@ -0,0 +1,16 @@
+import { visit } from 'unist-util-visit';
+
+export default function () {
+ const data = this.data();
+ add('fromMarkdownExtensions', {
+ transforms: [
+ function (markdownAST) {
+ visit(markdownAST, node => delete node.position);
+ }
+ ]
+ });
+ function add(field, value) {
+ if (data[field]) data[field].push(value);
+ else data[field] = [value];
+ }
+}
diff --git a/src/sort.js b/src/sort.js
new file mode 100644
index 000000000..db27b02d5
--- /dev/null
+++ b/src/sort.js
@@ -0,0 +1,138 @@
+import parseMarkdown from './remark-parse.js';
+import chalk from 'chalk';
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Sort two documentation objects, given an optional order object. Returns
+ * a numeric sorting value that is compatible with stream-sort.
+ *
+ * @param {Array} comments all comments
+ * @param {Object} options options from documentation.yml
+ * @returns {number} sorting value
+ * @private
+ */
+export default function (comments, options) {
+ if (!options || !options.toc) {
+ return sortComments(comments, options && options.sortOrder);
+ }
+ let i = 0;
+ const indexes = Object.create(null);
+ const toBeSorted = Object.create(null);
+ const paths = Object.create(null);
+ const fixed = [];
+ const walk = function (tocPath, val) {
+ if (typeof val === 'object' && val.name) {
+ val.kind = 'note';
+ indexes[val.name] = i++;
+ if (typeof val.file === 'string') {
+ let filename = val.file;
+ if (!path.isAbsolute(val.file)) {
+ filename = path.join(process.cwd(), val.file);
+ }
+
+ try {
+ val.description = fs.readFileSync(filename).toString();
+ delete val.file;
+ } catch (err) {
+ process.stderr.write(chalk.red(`Failed to read file ${filename}`));
+ }
+ } else if (!val.description) {
+ val.description = '';
+ }
+ if (typeof val.description === 'string') {
+ val.description = parseMarkdown(val.description);
+ }
+ const childPath = tocPath.concat({ scope: 'static', name: val.name });
+ val.path = childPath;
+ if (val.children) {
+ val.children.forEach(walk.bind(null, childPath));
+ }
+ fixed.push(val);
+ } else {
+ indexes[val] = i++;
+ toBeSorted[val] = false;
+ paths[val] = tocPath.concat({ scope: 'static', name: val, toc: true });
+ }
+ };
+ // Table of contents 'theme' entries: defined as objects
+ // in the YAML list
+ options.toc.forEach(walk.bind(null, []));
+ const unfixed = [];
+ comments.forEach(function (comment) {
+ let commentPath;
+ if (!comment.memberof && (commentPath = paths[comment.name])) {
+ comment.path = commentPath;
+ delete paths[comment.name];
+ }
+
+ // If comment is of kind 'note', this means that we must be _re_ sorting
+ // the list, and the TOC note entries were already added to the list. Bail
+ // out here so that we don't add duplicates.
+ if (comment.kind === 'note') {
+ return;
+ }
+
+ // If comment is top-level and `name` matches a TOC entry, add it to the
+ // to-be-sorted list.
+ if (!comment.memberof && indexes[comment.name] !== undefined) {
+ fixed.push(comment);
+ toBeSorted[comment.name] = true;
+ } else {
+ unfixed.push(comment);
+ }
+ });
+ fixed.sort((a, b) => {
+ if (indexes[a.name] !== undefined && indexes[b.name] !== undefined) {
+ return indexes[a.name] - indexes[b.name];
+ }
+ return 0;
+ });
+ sortComments(unfixed, options.sortOrder);
+ Object.keys(toBeSorted)
+ .filter(key => toBeSorted[key] === false)
+ .forEach(key => {
+ process.stderr.write(
+ chalk.red(
+ 'Table of contents defined sorting of ' +
+ key +
+ ' but no documentation with that namepath was found\n'
+ )
+ );
+ });
+ return fixed.concat(unfixed);
+}
+
+function compareCommentsByField(field, a, b) {
+ const akey = a[field];
+ const bkey = b[field];
+
+ if (akey && bkey) {
+ return akey.localeCompare(bkey, undefined, { caseFirst: 'upper' });
+ }
+ if (akey) return 1;
+ if (bkey) return -1;
+ return 0;
+}
+
+function compareCommentsBySourceLocation(a, b) {
+ return a.context.sortKey.localeCompare(b.context.sortKey);
+}
+
+const sortFns = {
+ alpha: compareCommentsByField.bind(null, 'name'),
+ source: compareCommentsBySourceLocation,
+ kind: compareCommentsByField.bind(null, 'kind'),
+ access: compareCommentsByField.bind(null, 'access'),
+ memberof: compareCommentsByField.bind(null, 'memberof')
+};
+
+function sortComments(comments, sortOrder) {
+ return comments.sort((a, b) => {
+ for (const sortMethod of sortOrder || ['source']) {
+ const r = sortFns[sortMethod](a, b);
+ if (r !== 0) return r;
+ }
+ return 0;
+ });
+}
diff --git a/src/ts_doctrine.js b/src/ts_doctrine.js
new file mode 100644
index 000000000..d31a0a50b
--- /dev/null
+++ b/src/ts_doctrine.js
@@ -0,0 +1,180 @@
+import generator from '@babel/generator';
+const generate = generator.default || generator;
+
+const namedTypes = {
+ TSBigIntKeyword: 'bigint',
+ TSNumberKeyword: 'number',
+ TSBooleanKeyword: 'boolean',
+ TSStringKeyword: 'string',
+ TSSymbolKeyword: 'symbol',
+ TSThisType: 'this',
+ TSObjectKeyword: 'object',
+ TSNeverKeyword: 'never'
+};
+
+const oneToOne = {
+ TSAnyKeyword: 'AllLiteral',
+ TSUnknownKeyword: 'AllLiteral',
+ TSNullKeyword: 'NullLiteral',
+ TSUndefinedKeyword: 'UndefinedLiteral',
+ TSVoidKeyword: 'VoidLiteral'
+};
+
+function propertyToField(property) {
+ if (!property.typeAnnotation) return null;
+
+ let type = tsDoctrine(property.typeAnnotation.typeAnnotation);
+ if (property.optional) {
+ // Doctrine does not support optional fields but it does have something called optional types
+ // (which makes no sense, but let's play along).
+ type = {
+ type: 'OptionalType',
+ expression: type
+ };
+ }
+ return {
+ type: 'FieldType',
+ key: property.key ? property.key.name || property.key.value : '',
+ value: type
+ };
+}
+
+/**
+ * Babel parses TypeScript annotations in JavaScript into AST nodes. documentation.js uses
+ * Babel to parse TypeScript. This method restructures those Babel-generated
+ * objects into objects that fit the output of Doctrine, the module we use
+ * to parse JSDoc annotations. This lets us use TypeScript annotations _as_
+ * JSDoc annotations.
+ *
+ * @private
+ * @param {Object} type babel-parsed typescript type
+ * @returns {Object} doctrine compatible type
+ */
+function tsDoctrine(type) {
+ if (type.type in namedTypes) {
+ const doctrineType = {
+ type: 'NameExpression',
+ name: namedTypes[type.type]
+ };
+ return doctrineType;
+ }
+
+ // TODO: unhandled types
+ // TSIntersectionType, TSConditionalType, TSInferType, TSTypeOperator, TSIndexedAccessType
+ // TSMappedType, TSImportType, TSTypePredicate, TSTypeQuery, TSExpressionWithTypeArguments
+
+ if (type.type in oneToOne) {
+ return { type: oneToOne[type.type] };
+ }
+
+ switch (type.type) {
+ case 'TSOptionalType':
+ return {
+ type: 'NullableType',
+ expression: tsDoctrine(type.typeAnnotation)
+ };
+ case 'TSParenthesizedType':
+ return tsDoctrine(type.typeAnnotation);
+ case 'TSUnionType':
+ return {
+ type: 'UnionType',
+ elements: type.types.map(tsDoctrine)
+ };
+ // [number]
+ // [string, boolean, number]
+ case 'TSTupleType':
+ return {
+ type: 'ArrayType',
+ elements: type.elementTypes.map(tsDoctrine)
+ };
+ // number[]
+ case 'TSArrayType':
+ return {
+ type: 'TypeApplication',
+ expression: {
+ type: 'NameExpression',
+ name: 'Array'
+ },
+ applications: [tsDoctrine(type.elementType)]
+ };
+ // ...string
+ case 'TSRestType':
+ return {
+ type: 'RestType',
+ expression: tsDoctrine(type.typeAnnotation)
+ };
+ // (y: number) => bool
+ case 'TSFunctionType':
+ case 'TSConstructorType':
+ case 'TSMethodSignature':
+ return {
+ type: 'FunctionType',
+ params: type.parameters.map(param => {
+ if (param.type === 'RestElement') {
+ return {
+ type: 'RestType',
+ expression: {
+ type: 'ParameterType',
+ name: param.argument.name,
+ expression: tsDoctrine(param.typeAnnotation.typeAnnotation)
+ }
+ };
+ }
+
+ return {
+ type: 'ParameterType',
+ name: param.name,
+ expression: tsDoctrine(param.typeAnnotation.typeAnnotation)
+ };
+ }),
+ result: tsDoctrine(type.typeAnnotation.typeAnnotation)
+ };
+
+ case 'TSTypeReference':
+ if (type.typeParameters) {
+ return {
+ type: 'TypeApplication',
+ expression: {
+ type: 'NameExpression',
+ name: generate(type.typeName, {
+ compact: true
+ }).code
+ },
+ applications: type.typeParameters.params.map(tsDoctrine)
+ };
+ }
+
+ return {
+ type: 'NameExpression',
+ name: generate(type.typeName, {
+ compact: true
+ }).code
+ };
+
+ case 'TSTypeLiteral':
+ if (type.members) {
+ return {
+ type: 'RecordType',
+ fields: type.members.map(propertyToField).filter(x => x)
+ };
+ }
+
+ return {
+ type: 'NameExpression',
+ name: generate(type.id, {
+ compact: true
+ }).code
+ };
+ case 'TSLiteralType':
+ return {
+ type: `${type.literal.type}Type`,
+ value: type.literal.value
+ };
+ default:
+ return {
+ type: 'AllLiteral'
+ };
+ }
+}
+
+export default tsDoctrine;
diff --git a/src/type_annotation.js b/src/type_annotation.js
new file mode 100644
index 000000000..b1e327ced
--- /dev/null
+++ b/src/type_annotation.js
@@ -0,0 +1,21 @@
+import t from '@babel/types';
+import flowDoctrine from './flow_doctrine.js';
+import tsDoctrine from './ts_doctrine.js';
+
+function typeAnnotation(type) {
+ if (t.isFlow(type)) {
+ if (t.isTypeAnnotation(type)) {
+ type = type.typeAnnotation;
+ }
+
+ return flowDoctrine(type);
+ }
+
+ if (t.isTSTypeAnnotation(type)) {
+ type = type.typeAnnotation;
+ }
+
+ return tsDoctrine(type);
+}
+
+export default typeAnnotation;
diff --git a/lib/walk.js b/src/walk.js
similarity index 75%
rename from lib/walk.js
rename to src/walk.js
index dc9069b59..255d83160 100644
--- a/lib/walk.js
+++ b/src/walk.js
@@ -7,14 +7,12 @@
* @param {Object} [options] options passed through to walker function
* @returns {Array} comments
*/
-function walk(comments, fn, options) {
- comments.forEach(function (comment) {
+export default function walk(comments, fn, options) {
+ comments.forEach(comment => {
fn(comment, options);
- for (var scope in comment.members) {
+ for (const scope in comment.members) {
walk(comment.members[scope], fn, options);
}
});
return comments;
}
-
-module.exports = walk;
diff --git a/test/bin-readme.js b/test/bin-readme.js
deleted file mode 100644
index 2337ac8c7..000000000
--- a/test/bin-readme.js
+++ /dev/null
@@ -1,114 +0,0 @@
-var test = require('tap').test,
- path = require('path'),
- os = require('os'),
- exec = require('child_process').exec,
- tmp = require('tmp'),
- fs = require('fs-extra');
-
-function documentation(args, options, callback, parseJSON) {
- if (!callback) {
- callback = options;
- options = {};
- }
-
- if (!options.cwd) {
- options.cwd = __dirname;
- }
-
- options.maxBuffer = 1024 * 1024;
-
- args.unshift(path.join(__dirname, '../bin/documentation.js'));
-
- exec(args.join(' '), options, callback);
-}
-
-var UPDATE = !!process.env.UPDATE;
-
-test('readme command', function (group) {
- var fixtures = path.join(__dirname, 'fixture/readme');
- var sourceFile = path.join(fixtures, 'index.js');
-
- tmp.dir({unsafeCleanup: true}, function (err, d) {
- group.error(err);
- fs.copySync(path.join(fixtures, 'README.input.md'), path.join(d, 'README.md'));
- fs.copySync(path.join(fixtures, 'index.js'), path.join(d, 'index.js'));
-
- // run tests after setting up temp dir
-
- group.test('--diff-only: changes needed', function (t) {
- t.error(err);
- var before = fs.readFileSync(path.join(d, 'README.md'), 'utf-8');
- documentation(['readme index.js --diff-only -s API'], {cwd: d}, function (err, stdout, stderr) {
- var after = fs.readFileSync(path.join(d, 'README.md'), 'utf-8');
- t.ok(err);
- t.notEqual(err.code, 0, 'exit nonzero');
- t.same(after, before, 'readme unchanged');
- t.end();
- });
- });
-
- var expectedFile = path.join(fixtures, 'README.output.md');
- var expectedPath = path.join(fixtures, 'README.output.md');
- var expected = fs.readFileSync(expectedFile, 'utf-8');
-
- group.test('updates README.md', function (t) {
- documentation(['readme index.js -s API'], {cwd: d}, function (err, stdout) {
- var outputPath = path.join(d, 'README.md');
- t.error(err);
-
- if (UPDATE) {
- fs.writeFileSync(expectedPath, fs.readFileSync(outputPath, 'utf-8'));
- }
-
- var actual = fs.readFileSync(outputPath, 'utf-8');
- t.same(actual, expected, 'generated readme output');
- t.end();
- });
- });
-
- group.test('--readme-file', function (t) {
- fs.copySync(path.join(fixtures, 'README.input.md'), path.join(d, 'other.md'));
- documentation(['readme index.js -s API --readme-file other.md'], {cwd: d}, function (err, stdout) {
- t.error(err);
- var actualPath = path.join(d, 'other.md');
- if (UPDATE) {
- fs.writeFileSync(actualPath, expected);
- }
- var actual = fs.readFileSync(actualPath, 'utf-8');
- t.same(actual, expected, 'generated readme output');
- t.end();
- });
- });
-
- group.test('--diff-only: changes NOT needed', function (t) {
- t.error(err);
- fs.copySync(path.join(fixtures, 'README.output.md'), path.join(d, 'uptodate.md'));
- documentation(['readme index.js --diff-only -s API --readme-file uptodate.md'],
- {cwd: d}, function (err, stdout, stderr) {
- t.error(err);
- t.match(stdout, 'is up to date.');
- t.end();
- });
- });
-
- group.test('requires -s option', function (t) {
- documentation(['readme index.js'], {cwd: d}, function (err, stdout, stderr) {
- t.ok(err);
- t.ok(err.code !== 0, 'exit nonzero');
- t.match(stderr, 'Missing required argument: s');
- t.end();
- });
- });
-
- group.test('errors if specified readme section is missing', function (t) {
- documentation(['readme index.js -s DUMMY'], {cwd: d}, function (err, stdout, stderr) {
- t.ok(err);
- t.ok(err.code !== 0, 'exit nonzero');
- t.end();
- });
- });
-
- group.end();
- });
-});
-
diff --git a/test/bin-watch-serve.js b/test/bin-watch-serve.js
deleted file mode 100644
index b54d3da49..000000000
--- a/test/bin-watch-serve.js
+++ /dev/null
@@ -1,129 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- path = require('path'),
- os = require('os'),
- get = require('./utils').get,
- spawn = require('child_process').spawn,
- fs = require('fs');
-
-function documentation(args, options, callback, parseJSON) {
- if (!callback) {
- callback = options;
- options = {};
- }
-
- if (!options.cwd) {
- options.cwd = __dirname;
- }
-
- options.maxBuffer = 1024 * 1024;
-
- return spawn(
- path.join(__dirname, '../bin/documentation.js'),
- args,
- options);
-}
-
-function normalize(result) {
- result.forEach(function (item) {
- item.context.file = '[path]';
- });
- return result;
-}
-
-var options = { timeout: 1000 * 120 };
-
-test('harness', options, function (t) {
- var docProcess = documentation(['fixture/simple.input.js', '--serve']);
- t.ok(docProcess, 'creates a subprocess object');
- docProcess.kill();
- t.end();
-});
-
-test('provides index.html', options, function (t) {
- var docProcess = documentation(['serve', 'fixture/simple.input.js']);
- docProcess.stdout.on('data', function (data) {
- t.equal(data.toString().trim(), 'documentation.js serving on port 4001', 'shows listening message');
- get('http://localhost:4001/', function (text) {
- t.ok(text.match(//), 'sends an html index file');
- docProcess.kill();
- t.end();
- });
- });
-});
-
-test('accepts port argument', options, function (t) {
- var docProcess = documentation(['serve', 'fixture/simple.input.js', '--port=4004']);
- docProcess.stdout.on('data', function (data) {
- t.equal(data.toString().trim(), 'documentation.js serving on port 4004', 'shows listening message');
- get('http://localhost:4004/', function (text) {
- t.ok(text.match(//), 'sends an html index file');
- docProcess.kill();
- t.end();
- });
- });
-});
-
-test('--watch', options, function (t) {
- var tmpFile = path.join(os.tmpdir(), '/simple.js');
- fs.writeFileSync(tmpFile, '/** a function */function apples() {}');
- var docProcess = documentation(['serve', tmpFile, '--watch']);
- docProcess.stdout.on('data', function (data) {
- get('http://localhost:4001/', function (text) {
- t.ok(text.match(/apples/), 'sends an html index file');
- fs.writeFileSync(tmpFile, '/** a function */function bananas() {}');
- function doGet() {
- get('http://localhost:4001/', function (text) {
- if (text.match(/bananas/)) {
- docProcess.kill();
- t.end();
- } else {
- setTimeout(doGet, 100);
- }
- });
- }
- doGet();
- });
- });
-});
-
-test('--watch', options, function (t) {
- var tmpDir = os.tmpdir();
- var a = path.join(tmpDir, '/simple.js');
- var b = path.join(tmpDir, '/required.js');
- fs.writeFileSync(a, 'require("./required")');
- fs.writeFileSync(b, '/** soup */function soup() {}');
- var docProcess = documentation(['serve', a, '--watch']);
- docProcess.stdout.on('data', function (data) {
- get('http://localhost:4001/', function (text) {
- t.ok(text.match(/soup/), 'sends an html index file');
- fs.writeFileSync(b, '/** nuts */function nuts() {}');
- function doGet() {
- get('http://localhost:4001/', function (text) {
- if (text.match(/nuts/)) {
- docProcess.kill();
- t.end();
- } else {
- setTimeout(doGet, 100);
- }
- });
- }
- doGet();
- });
- });
-});
-
-test('error page', options, function (t) {
- var tmpDir = os.tmpdir();
- var a = path.join(tmpDir, '/simple.js');
- fs.writeFileSync(a, '**');
- var docProcess = documentation(['serve', a, '--watch']);
- docProcess.stdout.on('data', function (data) {
- get('http://localhost:4001/', function (text) {
- t.ok(text.match(/Unexpected token/), 'emits an error page');
- docProcess.kill();
- t.end();
- });
- });
-});
diff --git a/test/bin.js b/test/bin.js
deleted file mode 100644
index 24301843a..000000000
--- a/test/bin.js
+++ /dev/null
@@ -1,377 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- path = require('path'),
- os = require('os'),
- exec = require('child_process').exec,
- tmp = require('tmp'),
- fs = require('fs-extra');
-
-function documentation(args, options, callback, parseJSON) {
- if (!callback) {
- parseJSON = callback;
- callback = options;
- options = {};
- }
-
- if (!options.cwd) {
- options.cwd = __dirname;
- }
-
- options.maxBuffer = 1024 * 1024;
-
- args.unshift(path.join(__dirname, '../bin/documentation.js'));
-
- exec(args.join(' '), options, function (err, stdout, stderr) {
- if (err) {
- return callback(err, stdout, stderr);
- }
- if (parseJSON === false) {
- callback(err, stdout, stderr);
- } else {
- callback(err, JSON.parse(stdout), stderr);
- }
- });
-}
-
-function normalize(result) {
- result.forEach(function (item) {
- item.context.file = '[path]';
- });
- return result;
-}
-
-var options = { timeout: 1000 * 120 };
-
-test('documentation binary', options, function (t) {
- documentation(['build fixture/simple.input.js'], function (err, data) {
- t.error(err);
- t.equal(data.length, 1, 'simple has no dependencies');
- t.end();
- });
-});
-
-test('defaults to parsing package.json main', options, function (t) {
- documentation(['build'], { cwd: path.join(__dirname, '..') }, function (err, data) {
- t.error(err);
- t.ok(data.length, 'we document ourself');
- t.end();
- });
-});
-
-test('polyglot mode', options, function (t) {
- documentation(['build fixture/polyglot/blend.cpp --polyglot'],
- function (err, data) {
- t.ifError(err);
- if (process.env.UPDATE) {
- fs.writeFileSync(
- path.resolve(__dirname,
- 'fixture',
- 'polyglot/blend.json'), JSON.stringify(normalize(data), null, 2), 'utf8');
- }
- var expected = fs.readFileSync(
- path.resolve(__dirname,
- 'fixture',
- 'polyglot/blend.json'), 'utf8');
- t.deepEqual(
- normalize(data),
- JSON.parse(expected),
- 'parsed C++ file');
- t.end();
- });
-});
-
-test('accepts config file', options, function (t) {
- documentation(['build fixture/sorting/input.js -c fixture/config.json'],
- function (err, data) {
- t.error(err);
- if (process.env.UPDATE) {
- fs.writeFileSync(
- path.resolve(__dirname,
- 'fixture',
- 'sorting/output.json'), JSON.stringify(normalize(data), null, 2), 'utf8');
- }
- var expected = fs.readFileSync(
- path.resolve(__dirname,
- 'fixture',
- 'sorting/output.json'), 'utf8');
- t.deepEqual(
- normalize(data),
- JSON.parse(expected),
- 'respected sort order from config file');
- t.end();
- });
-});
-
-test('accepts config file - reports failures', options, function (t) {
- documentation(['build fixture/sorting/input.js -c fixture/config-bad.yml'], {},
- function (err, data, stderr) {
- t.error(err);
- if (process.env.UPDATE) {
- fs.writeFileSync(
- path.resolve(__dirname,
- 'fixture',
- 'sorting/output-bad.txt'), stderr, 'utf8');
- }
- var expected = fs.readFileSync(
- path.resolve(__dirname,
- 'fixture',
- 'sorting/output-bad.txt'), 'utf8');
- t.equal(stderr, expected, 'reported a missing toc entry');
- t.end();
- }, false);
-});
-
-test('--shallow option', function (t) {
- documentation(['build --shallow fixture/internal.input.js'], function (err, data) {
- t.error(err);
- t.equal(data.length, 0, 'should not check dependencies');
- t.end();
- });
-});
-
-test('external modules option', function (t) {
- documentation(['build fixture/external.input.js ' +
- '--external=external --external=external/node_modules'], function (err, data) {
- t.ifError(err);
- t.equal(data.length, 2, 'Includes external file');
- t.end();
- });
-});
-
-test('extension option', function (t) {
- documentation(['build fixture/extension/index.otherextension ' +
- '--extension=otherextension'], function (err, data) {
- t.ifError(err);
- t.equal(data.length, 1, 'includes a file with an arbitrary extension');
- t.end();
- });
-});
-
-test('extension option', function (t) {
- documentation(['build fixture/extension.jsx'], function (err, data) {
- t.ifError(err);
- t.end();
- });
-});
-
-test('invalid arguments', function (group) {
- group.test('bad -f option', options, function (t) {
- documentation(['build -f DOES-NOT-EXIST fixture/internal.input.js'], {}, function (err) {
- t.ok(err, 'returns error');
- t.end();
- }, false);
- });
-
- group.test('html with no destination', options, function (t) {
- documentation(['build -f html fixture/internal.input.js'], function (err) {
- t.ok(err.toString()
- .match(/The HTML output mode requires a destination directory set with -o/),
- 'needs dest for html');
- t.end();
- });
- });
-
- group.test('bad command', function (t) {
- documentation(['-f html fixture/internal.input.js'], {}, function (err, stdout, stderr) {
- t.ok(err.code, 'exits nonzero');
- t.end();
- }, false);
- });
-
- group.end();
-});
-
-test('--config', options, function (t) {
- var dst = path.join(os.tmpdir(), (Date.now() + Math.random()).toString());
- fs.mkdirSync(dst);
- var outputIndex = path.join(dst, 'index.html');
- var expectedOutputPath = path.join(__dirname, 'fixture/html/nested.config-output.html');
- documentation(['build -c fixture/html/documentation.yml -f html fixture/html/nested.input.js -o ' +
- dst], function (err) {
- t.notOk(err);
- var output = fs.readFileSync(outputIndex, 'utf8');
- if (process.env.UPDATE) {
- fs.writeFileSync(expectedOutputPath, output);
- }
- var expectedOutput = fs.readFileSync(expectedOutputPath, 'utf8');
- t.equal(expectedOutput, output, 'generates correct output');
- t.end();
- }, false);
-});
-
-test('--version', options, function (t) {
- documentation(['--version'], {}, function (err, output) {
- t.ok(output, 'outputs version');
- t.end();
- }, false);
-});
-
-test('lint command', function (group) {
-
- group.test('generates lint output', options, function (t) {
- documentation(['lint fixture/lint/lint.input.js'], function (err, data) {
- var output = path.join(__dirname, 'fixture/lint/lint.output.js');
- data = data.toString().split('\n').slice(2).join('\n');
- if (process.env.UPDATE) {
- fs.writeFileSync(output, data);
- }
- t.equal(err.code, 1);
- t.equal(data, fs.readFileSync(output, 'utf8'), 'outputs lint');
- t.end();
- });
- });
-
- group.test('generates no output on a good file', options, function (t) {
- documentation(['lint fixture/simple.input.js'], {}, function (err, data) {
- t.equal(err, null);
- t.equal(data, '', 'no output');
- t.end();
- }, false);
- });
-
- group.test('exposes syntax error on a bad file', options, function (t) {
- documentation(['lint fixture/bad/syntax.input.js'], {}, function (err, data) {
- t.ok(err.code > 0, 'exits with a > 0 exit code');
- t.end();
- }, false);
- });
-
- group.end();
-});
-
-test('given no files', options, function (t) {
- documentation(['build'], function (err) {
- t.ok(err.toString()
- .match(/documentation was given no files and was not run in a module directory/),
- 'no files given');
- t.end();
- });
-});
-
-test('with an invalid command', options, function (t) {
- documentation(['invalid'], {}, function (err) {
- t.ok(err, 'returns error');
- t.end();
- }, false);
-});
-
-test('--access flag', function (t) {
- documentation(['build --shallow fixture/internal.input.js -a public'], {}, function (err, data) {
- t.error(err);
- t.equal(data, '[]');
- t.end();
- }, false);
-});
-
-test('--private flag', function (t) {
- documentation(['build fixture/internal.input.js --private'], {}, function (err, data) {
- t.error(err);
- t.ok(data.length > 2, 'outputs docs');
- t.end();
- }, false);
-});
-
-test('--infer-private flag', function (t) {
- documentation(['build fixture/infer-private.input.js --infer-private ^_'], {}, function (err, data) {
- t.error(err);
-
- // This uses JSON.parse with a reviver used as a visitor.
- JSON.parse(data, function (n, v) {
- // Make sure we do not see any names that match `^_`.
- if (n === 'name') {
- t.equal(typeof v, 'string');
- t.ok(!/_$/.test(v));
- }
- return v;
- });
- t.end();
- }, false);
-});
-
-test('write to file', options, function (t) {
-
- var dst = path.join(os.tmpdir(), (Date.now() + Math.random()).toString());
-
- documentation(['build --shallow fixture/internal.input.js -o ' + dst], {}, function (err, data) {
- t.error(err);
- t.equal(data, '');
- t.ok(fs.existsSync(dst), 'created file');
- t.end();
- }, false);
-});
-
-test('write to html', options, function (t) {
-
- var dstDir = path.join(os.tmpdir(), (Date.now() + Math.random()).toString());
- fs.mkdirSync(dstDir);
-
- documentation(['build --shallow fixture/internal.input.js -f html -o ' + dstDir], {},
- function (err, data) {
- t.error(err);
- t.equal(data, '');
- t.ok(fs.existsSync(path.join(dstDir, 'index.html')), 'created index.html');
- t.end();
- }, false);
-});
-
-test('write to html with custom theme', options, function (t) {
-
- var dstDir = path.join(os.tmpdir(), (Date.now() + Math.random()).toString());
- fs.mkdirSync(dstDir);
-
- documentation(['build -t fixture/custom_theme --shallow fixture/internal.input.js -f html -o ' + dstDir], {},
- function (err, data) {
- t.error(err);
- t.equal(data, '');
- t.ok(fs.readFileSync(path.join(dstDir, 'index.html'), 'utf8'), 'Hello world');
- t.end();
- }, false);
-});
-
-test('write to html, highlightAuto', options, function (t) {
-
- var fixture = 'fixture/auto_lang_hljs/multilanguage.input.js',
- config = 'fixture/auto_lang_hljs/config.yml',
- dstDir = path.join(os.tmpdir(), (Date.now() + Math.random()).toString());
-
- fs.mkdirSync(dstDir);
-
- documentation(['build --shallow ' + fixture + ' -c ' + config + ' -f html -o ' + dstDir], {},
- function (err) {
- t.ifErr(err);
- var result = fs.readFileSync(path.join(dstDir, 'index.html'), 'utf8');
- t.ok(result.indexOf('42 ') > 0,
- 'javascript is recognized by highlightjs');
- t.ok(result.indexOf('[data-foo] ') > 0,
- 'css is recognized by highlightjs');
- t.ok(result.indexOf('data-foo ') > 0,
- 'html is recognized by highlightjs');
- t.end();
- }, false);
-});
-
-test('fatal error', options, function (t) {
-
- documentation(['build --shallow fixture/bad/syntax.input.js'], {},
- function (err) {
- t.ok(err.toString().match(/Unexpected token/), 'reports syntax error');
- t.end();
- }, false);
-});
-
-test('build --document-exported', function (t) {
-
- documentation(['build fixture/document-exported.input.js --document-exported -f md'], {}, function (err, data) {
- t.error(err);
-
- var outputfile = path.join(__dirname, 'fixture', 'document-exported.output.md');
- if (process.env.UPDATE) {
- fs.writeFileSync(outputfile, data, 'utf8');
- }
-
- var expect = fs.readFileSync(outputfile, 'utf-8');
- t.equal(data, expect);
- t.end();
- }, false);
-}, options);
diff --git a/test/fixture/boolean-literal-type.output.json b/test/fixture/boolean-literal-type.output.json
deleted file mode 100644
index 2ea4eb916..000000000
--- a/test/fixture/boolean-literal-type.output.json
+++ /dev/null
@@ -1,79 +0,0 @@
-[
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 1,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 2,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "f",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "t",
- "lineNumber": 2,
- "type": {
- "type": "BooleanLiteralType",
- "value": true
- }
- },
- {
- "title": "param",
- "name": "f",
- "lineNumber": 2,
- "type": {
- "type": "BooleanLiteralType",
- "value": false
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "ArrayType",
- "elements": [
- {
- "type": "BooleanLiteralType",
- "value": true
- },
- {
- "type": "BooleanLiteralType",
- "value": false
- }
- ]
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f",
- "kind": "function"
- }
- ],
- "namespace": "f"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/boolean-literal-type.output.md b/test/fixture/boolean-literal-type.output.md
deleted file mode 100644
index a3dbe313e..000000000
--- a/test/fixture/boolean-literal-type.output.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-# f
-
-**Parameters**
-
-- `t` **`true`**
-- `f` **`false`**
-
-Returns **\[`true`, `false`]**
diff --git a/test/fixture/boolean-literal-type.output.md.json b/test/fixture/boolean-literal-type.output.md.json
deleted file mode 100644
index 81739d92b..000000000
--- a/test/fixture/boolean-literal-type.output.md.json
+++ /dev/null
@@ -1,134 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "t"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "inlineCode",
- "value": "true"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "f"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "inlineCode",
- "value": "false"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "["
- },
- {
- "type": "inlineCode",
- "value": "true"
- },
- {
- "type": "text",
- "value": ", "
- },
- {
- "type": "inlineCode",
- "value": "false"
- },
- {
- "type": "text",
- "value": "]"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/class.output.json b/test/fixture/class.output.json
deleted file mode 100644
index c539e4535..000000000
--- a/test/fixture/class.output.json
+++ /dev/null
@@ -1,581 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is my class, a demo thing.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- }
- }
- },
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 2,
- "type": null,
- "name": "MyClass"
- },
- {
- "title": "property",
- "description": "how many things it contains",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "howMany"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 6,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 1
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "MyClass",
- "properties": [
- {
- "name": "howMany",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "how many things it contains",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get the number 42",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "whether to get the number",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- },
- "name": "getIt"
- },
- {
- "title": "returns",
- "description": "forty-two",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 14,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 15,
- "column": 0
- },
- "end": {
- "line": 17,
- "column": 2
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "getIt",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "whether to get the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "forty-two",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "getFoo",
- "kind": "function",
- "memberof": "MyClass",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "MyClass",
- "kind": "class"
- },
- {
- "name": "getFoo",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "MyClass#getFoo"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get undefined",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "does not return anything.",
- "lineNumber": 2,
- "type": {
- "type": "UndefinedLiteral"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 19,
- "column": 0
- },
- "end": {
- "line": 22,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 23,
- "column": 0
- },
- "end": {
- "line": 23,
- "column": 49
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "does not return anything.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- }
- }
- },
- "type": {
- "type": "UndefinedLiteral"
- }
- }
- ],
- "name": "getUndefined",
- "kind": "function",
- "memberof": "MyClass",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "MyClass",
- "kind": "class"
- },
- {
- "name": "getUndefined",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "MyClass#getUndefined"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "MyClass",
- "kind": "class"
- }
- ],
- "namespace": "MyClass"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/class.output.md b/test/fixture/class.output.md
deleted file mode 100644
index 371b57287..000000000
--- a/test/fixture/class.output.md
+++ /dev/null
@@ -1,25 +0,0 @@
-
-
-# MyClass
-
-This is my class, a demo thing.
-
-**Properties**
-
-- `howMany` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** how many things it contains
-
-## getFoo
-
-Get the number 42
-
-**Parameters**
-
-- `getIt` **[boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** whether to get the number
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** forty-two
-
-## getUndefined
-
-Get undefined
-
-Returns **[undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)** does not return anything.
diff --git a/test/fixture/class.output.md.json b/test/fixture/class.output.md.json
deleted file mode 100644
index 1e7d5837a..000000000
--- a/test/fixture/class.output.md.json
+++ /dev/null
@@ -1,448 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "MyClass"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is my class, a demo thing.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "howMany"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "how many things it contains",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getFoo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get the number 42",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "getIt"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "boolean"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "whether to get the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "forty-two",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getUndefined"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get undefined",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "undefined"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "does not return anything.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/document-exported.output.json b/test/fixture/document-exported.output.json
deleted file mode 100644
index b886f3cbc..000000000
--- a/test/fixture/document-exported.output.json
+++ /dev/null
@@ -1,1445 +0,0 @@
-[
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 1
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "z",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 2,
- "column": 2
- },
- "end": {
- "line": 2,
- "column": 14
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 2,
- "column": 2
- },
- "end": {
- "line": 2,
- "column": 14
- }
- }
- },
- "errors": [],
- "name": "zMethod",
- "kind": "function",
- "memberof": "z",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "z",
- "kind": "class"
- },
- {
- "name": "zMethod",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "z#zMethod"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "z",
- "kind": "class"
- }
- ],
- "namespace": "z"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 1,
- "column": 28
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 1,
- "column": 28
- }
- }
- },
- "errors": [],
- "name": "x",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "yparam",
- "lineNumber": 1
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "x",
- "kind": "function"
- }
- ],
- "namespace": "x"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 10,
- "column": 1
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 10,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "Class",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 4,
- "column": 2
- },
- "end": {
- "line": 4,
- "column": 18
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 2
- },
- "end": {
- "line": 4,
- "column": 18
- }
- }
- },
- "errors": [],
- "name": "classMethod",
- "kind": "function",
- "memberof": "Class",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- },
- {
- "name": "classMethod",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "Class#classMethod"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 5,
- "column": 2
- },
- "end": {
- "line": 5,
- "column": 22
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 2
- },
- "end": {
- "line": 5,
- "column": 22
- }
- }
- },
- "errors": [],
- "name": "classGetter",
- "kind": "member",
- "memberof": "Class",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- },
- {
- "name": "classGetter",
- "kind": "member",
- "scope": "instance"
- }
- ],
- "namespace": "Class#classGetter"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 6,
- "column": 2
- },
- "end": {
- "line": 6,
- "column": 23
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 6,
- "column": 2
- },
- "end": {
- "line": 6,
- "column": 23
- }
- }
- },
- "errors": [],
- "name": "classSetter",
- "kind": "member",
- "params": [
- {
- "title": "param",
- "name": "v",
- "lineNumber": 6
- }
- ],
- "memberof": "Class",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- },
- {
- "name": "classSetter",
- "kind": "member",
- "scope": "instance"
- }
- ],
- "namespace": "Class#classSetter"
- }
- ],
- "static": [
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 7,
- "column": 2
- },
- "end": {
- "line": 7,
- "column": 26
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 2
- },
- "end": {
- "line": 7,
- "column": 26
- }
- }
- },
- "errors": [],
- "name": "staticMethod",
- "kind": "function",
- "memberof": "Class",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- },
- {
- "name": "staticMethod",
- "kind": "function",
- "scope": "static"
- }
- ],
- "namespace": "Class.staticMethod"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 8,
- "column": 2
- },
- "end": {
- "line": 8,
- "column": 30
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 8,
- "column": 2
- },
- "end": {
- "line": 8,
- "column": 30
- }
- }
- },
- "errors": [],
- "name": "staticGetter",
- "kind": "member",
- "memberof": "Class",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- },
- {
- "name": "staticGetter",
- "kind": "member",
- "scope": "static"
- }
- ],
- "namespace": "Class.staticGetter"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 9,
- "column": 2
- },
- "end": {
- "line": 9,
- "column": 31
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 9,
- "column": 2
- },
- "end": {
- "line": 9,
- "column": 31
- }
- }
- },
- "errors": [],
- "name": "staticSetter",
- "kind": "member",
- "params": [
- {
- "title": "param",
- "name": "v",
- "lineNumber": 9
- }
- ],
- "memberof": "Class",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- },
- {
- "name": "staticSetter",
- "kind": "member",
- "scope": "static"
- }
- ],
- "namespace": "Class.staticSetter"
- }
- ],
- "events": []
- },
- "path": [
- {
- "name": "Class",
- "kind": "class"
- }
- ],
- "namespace": "Class"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 25
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 25
- }
- }
- },
- "errors": [],
- "name": "T5",
- "kind": "typedef",
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "T5",
- "kind": "typedef"
- }
- ],
- "namespace": "T5"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 18
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 18
- }
- }
- },
- "errors": [],
- "name": "y2Default",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "y2Default"
- }
- ],
- "namespace": "y2Default"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Description of y3",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 24
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 8,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 31
- }
- }
- },
- "errors": [],
- "name": "y4",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "p",
- "lineNumber": 8,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "VoidLiteral"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "y4",
- "kind": "function"
- }
- ],
- "namespace": "y4"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 12,
- "column": 0
- },
- "end": {
- "line": 18,
- "column": 2
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 12,
- "column": 0
- },
- "end": {
- "line": 18,
- "column": 2
- }
- }
- },
- "errors": [],
- "name": "object",
- "members": {
- "instance": [],
- "static": [
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 16,
- "column": 2
- },
- "end": {
- "line": 16,
- "column": 10
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 16,
- "column": 2
- },
- "end": {
- "line": 16,
- "column": 10
- }
- }
- },
- "errors": [],
- "name": "prop",
- "memberof": "object",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "object"
- },
- {
- "name": "prop",
- "scope": "static"
- }
- ],
- "namespace": "object.prop"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 17,
- "column": 2
- },
- "end": {
- "line": 17,
- "column": 21
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 17,
- "column": 2
- },
- "end": {
- "line": 17,
- "column": 21
- }
- }
- },
- "errors": [],
- "name": "func",
- "kind": "function",
- "memberof": "object",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "object"
- },
- {
- "name": "func",
- "kind": "function",
- "scope": "static"
- }
- ],
- "namespace": "object.func"
- }
- ]
- },
- "path": [
- {
- "name": "object"
- }
- ],
- "namespace": "object"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 13,
- "column": 2
- },
- "end": {
- "line": 13,
- "column": 13
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 2
- },
- "end": {
- "line": 13,
- "column": 13
- }
- }
- },
- "errors": [],
- "name": "method",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "method",
- "kind": "function"
- }
- ],
- "namespace": "method"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 14,
- "column": 2
- },
- "end": {
- "line": 14,
- "column": 17
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 14,
- "column": 2
- },
- "end": {
- "line": 14,
- "column": 17
- }
- }
- },
- "errors": [],
- "name": "getter",
- "kind": "member",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "getter",
- "kind": "member"
- }
- ],
- "namespace": "getter"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 15,
- "column": 2
- },
- "end": {
- "line": 15,
- "column": 18
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 15,
- "column": 2
- },
- "end": {
- "line": 15,
- "column": 18
- }
- }
- },
- "errors": [],
- "name": "setter",
- "kind": "member",
- "params": [
- {
- "title": "param",
- "name": "v",
- "lineNumber": 15
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "setter",
- "kind": "member"
- }
- ],
- "namespace": "setter"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 54,
- "column": 0
- },
- "end": {
- "line": 54,
- "column": 16
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 54,
- "column": 0
- },
- "end": {
- "line": 54,
- "column": 16
- }
- }
- },
- "errors": [],
- "name": "f1",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f1",
- "kind": "function"
- }
- ],
- "namespace": "f1"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 55,
- "column": 0
- },
- "end": {
- "line": 55,
- "column": 16
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 55,
- "column": 0
- },
- "end": {
- "line": 55,
- "column": 16
- }
- }
- },
- "errors": [],
- "name": "f3",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f3",
- "kind": "function"
- }
- ],
- "namespace": "f3"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 59,
- "column": 0
- },
- "end": {
- "line": 59,
- "column": 23
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 59,
- "column": 0
- },
- "end": {
- "line": 59,
- "column": 23
- }
- }
- },
- "errors": [],
- "name": "T",
- "kind": "typedef",
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "T",
- "kind": "typedef"
- }
- ],
- "namespace": "T"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 60,
- "column": 0
- },
- "end": {
- "line": 60,
- "column": 17
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 60,
- "column": 0
- },
- "end": {
- "line": 60,
- "column": 17
- }
- }
- },
- "errors": [],
- "name": "T2",
- "kind": "typedef",
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "T2",
- "kind": "typedef"
- }
- ],
- "namespace": "T2"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 61,
- "column": 0
- },
- "end": {
- "line": 61,
- "column": 17
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 61,
- "column": 0
- },
- "end": {
- "line": 61,
- "column": 17
- }
- }
- },
- "errors": [],
- "name": "T4",
- "kind": "typedef",
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "T4",
- "kind": "typedef"
- }
- ],
- "namespace": "T4"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 67,
- "column": 0
- },
- "end": {
- "line": 67,
- "column": 33
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 67,
- "column": 0
- },
- "end": {
- "line": 67,
- "column": 33
- }
- }
- },
- "errors": [],
- "name": "f4",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "x",
- "lineNumber": 67,
- "type": {
- "type": "NameExpression",
- "name": "X"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f4",
- "kind": "function"
- }
- ],
- "namespace": "f4"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 72,
- "column": 0
- },
- "end": {
- "line": 74,
- "column": 1
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 72,
- "column": 0
- },
- "end": {
- "line": 74,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "o1",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "o1"
- }
- ],
- "namespace": "o1"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 73,
- "column": 2
- },
- "end": {
- "line": 73,
- "column": 10
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 73,
- "column": 2
- },
- "end": {
- "line": 73,
- "column": 10
- }
- }
- },
- "errors": [],
- "name": "om1",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "om1",
- "kind": "function"
- }
- ],
- "namespace": "om1"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "f5 comment",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 76,
- "column": 0
- },
- "end": {
- "line": 76,
- "column": 17
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 77,
- "column": 0
- },
- "end": {
- "line": 80,
- "column": 4
- }
- }
- },
- "errors": [],
- "name": "f5",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "y",
- "lineNumber": 77,
- "type": {
- "type": "NameExpression",
- "name": "Y"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f5",
- "kind": "function"
- }
- ],
- "namespace": "f5"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 78,
- "column": 2
- },
- "end": {
- "line": 80,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 78,
- "column": 2
- },
- "end": {
- "line": 80,
- "column": 3
- }
- }
- },
- "errors": [],
- "name": "o2",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "o2"
- }
- ],
- "namespace": "o2"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 79,
- "column": 4
- },
- "end": {
- "line": 79,
- "column": 12
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 79,
- "column": 4
- },
- "end": {
- "line": 79,
- "column": 12
- }
- }
- },
- "errors": [],
- "name": "om2",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "om2",
- "kind": "function"
- }
- ],
- "namespace": "om2"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/document-exported.output.md b/test/fixture/document-exported.output.md
deleted file mode 100644
index 050ee4474..000000000
--- a/test/fixture/document-exported.output.md
+++ /dev/null
@@ -1,95 +0,0 @@
-
-
-# z
-
-## zMethod
-
-# x
-
-**Parameters**
-
-- `yparam`
-
-# Class
-
-## classMethod
-
-## classGetter
-
-## classSetter
-
-**Parameters**
-
-- `v`
-
-## staticMethod
-
-## staticGetter
-
-## staticSetter
-
-**Parameters**
-
-- `v`
-
-# T5
-
-# y2Default
-
-# y4
-
-Description of y3
-
-**Parameters**
-
-- `p` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-
-Returns **void**
-
-# object
-
-## prop
-
-## func
-
-# method
-
-# getter
-
-# setter
-
-**Parameters**
-
-- `v`
-
-# f1
-
-# f3
-
-# T
-
-# T2
-
-# T4
-
-# f4
-
-**Parameters**
-
-- `x` **X**
-
-# o1
-
-# om1
-
-# f5
-
-f5 comment
-
-**Parameters**
-
-- `y` **Y**
-
-# o2
-
-# om2
diff --git a/test/fixture/document-exported.output.md.json b/test/fixture/document-exported.output.md.json
deleted file mode 100644
index ea3cff981..000000000
--- a/test/fixture/document-exported.output.md.json
+++ /dev/null
@@ -1,694 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "z"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "zMethod"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "x"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "yparam"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Class"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "classMethod"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "classGetter"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "classSetter"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "v"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "staticMethod"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "staticGetter"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "staticSetter"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "v"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "T5"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "y2Default"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "y4"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Description of y3",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "p"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "void"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "object"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "prop"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "func"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "method"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getter"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "setter"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "v"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f1"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f3"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "T"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "T2"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "T4"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f4"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "X"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "o1"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "om1"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f5"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "f5 comment",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "y"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Y"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "o2"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "om2"
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/document-exported/x.js b/test/fixture/document-exported/x.js
deleted file mode 100644
index 1757ae6d0..000000000
--- a/test/fixture/document-exported/x.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export {y as x, y3} from './y.js';
-
-export type T5 = boolean;
diff --git a/test/fixture/es6-class.input.js b/test/fixture/es6-class.input.js
deleted file mode 100644
index 256d954db..000000000
--- a/test/fixture/es6-class.input.js
+++ /dev/null
@@ -1,22 +0,0 @@
-/**
- * This is my component. This is from issue #458
- */
-class Foo extends React.Component {}
-
-/**
- * Does nothing. This is from issue #556
- */
-export default class Bar {
-
- /**
- * Creates a new instance
- * @param {string} str
- */
- constructor(str) {
- /**
- * A useless property
- * @type {string}
- */
- this.bar = "";
- }
-}
diff --git a/test/fixture/es6-class.output.json b/test/fixture/es6-class.output.json
deleted file mode 100644
index acdacf6b3..000000000
--- a/test/fixture/es6-class.output.json
+++ /dev/null
@@ -1,417 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is my component. This is from issue #458",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 46,
- "offset": 45
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 46,
- "offset": 45
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 46,
- "offset": 45
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 36
- }
- }
- },
- "errors": [],
- "name": "Foo",
- "augments": [
- {
- "title": "augments",
- "name": "React.Component"
- }
- ],
- "kind": "class",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Foo",
- "kind": "class"
- }
- ],
- "namespace": "Foo"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Does nothing. This is from issue #556",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 6,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 9,
- "column": 0
- },
- "end": {
- "line": 22,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "Bar",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Creates a new instance",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": null,
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "str"
- }
- ],
- "loc": {
- "start": {
- "line": 11,
- "column": 4
- },
- "end": {
- "line": 14,
- "column": 7
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 15,
- "column": 4
- },
- "end": {
- "line": 21,
- "column": 5
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "str",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ],
- "name": "constructor",
- "kind": "function",
- "memberof": "Bar",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Bar",
- "kind": "class"
- },
- {
- "name": "constructor",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "Bar#constructor"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A useless property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- }
- }
- },
- "tags": [
- {
- "title": "type",
- "description": null,
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 16,
- "column": 8
- },
- "end": {
- "line": 19,
- "column": 11
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 20,
- "column": 8
- },
- "end": {
- "line": 20,
- "column": 22
- }
- }
- },
- "errors": [],
- "name": "bar",
- "memberof": "Bar",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Bar",
- "kind": "class"
- },
- {
- "name": "bar",
- "scope": "instance"
- }
- ],
- "namespace": "Bar#bar"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "Bar",
- "kind": "class"
- }
- ],
- "namespace": "Bar"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/es6-class.output.md b/test/fixture/es6-class.output.md
deleted file mode 100644
index 43266e7ba..000000000
--- a/test/fixture/es6-class.output.md
+++ /dev/null
@@ -1,23 +0,0 @@
-
-
-# Foo
-
-**Extends React.Component**
-
-This is my component. This is from issue #458
-
-# Bar
-
-Does nothing. This is from issue #556
-
-## constructor
-
-Creates a new instance
-
-**Parameters**
-
-- `str` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**
-
-## bar
-
-A useless property
diff --git a/test/fixture/es6-class.output.md.json b/test/fixture/es6-class.output.md.json
deleted file mode 100644
index b05fc7990..000000000
--- a/test/fixture/es6-class.output.md.json
+++ /dev/null
@@ -1,260 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Extends "
- },
- {
- "type": "text",
- "value": "React.Component"
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is my component. This is from issue #458",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 46,
- "offset": 45
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 46,
- "offset": 45
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Bar"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Does nothing. This is from issue #556",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "constructor"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Creates a new instance",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "str"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "bar"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A useless property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/es6-default2.input.js b/test/fixture/es6-default2.input.js
deleted file mode 100644
index 7bb836e7b..000000000
--- a/test/fixture/es6-default2.input.js
+++ /dev/null
@@ -1,4 +0,0 @@
-/**
- * @public
- */
-export default (thisIsTheArgument) => {};
diff --git a/test/fixture/es6-default2.output.json b/test/fixture/es6-default2.output.json
deleted file mode 100644
index 17bb6cac3..000000000
--- a/test/fixture/es6-default2.output.json
+++ /dev/null
@@ -1,56 +0,0 @@
-[
- {
- "description": "",
- "tags": [
- {
- "title": "public",
- "description": null,
- "lineNumber": 1
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 41
- }
- }
- },
- "errors": [],
- "access": "public",
- "name": "es6-default2.input",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "thisIsTheArgument",
- "lineNumber": 4
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "es6-default2.input",
- "kind": "function"
- }
- ],
- "namespace": "es6-default2.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/es6-default2.output.md b/test/fixture/es6-default2.output.md
deleted file mode 100644
index 946f20dba..000000000
--- a/test/fixture/es6-default2.output.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-# es6-default2.input
-
-**Parameters**
-
-- `thisIsTheArgument`
diff --git a/test/fixture/es6-default2.output.md.json b/test/fixture/es6-default2.output.md.json
deleted file mode 100644
index 764e3731a..000000000
--- a/test/fixture/es6-default2.output.md.json
+++ /dev/null
@@ -1,56 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "es6-default2.input"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "thisIsTheArgument"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/es6-import.input.js b/test/fixture/es6-import.input.js
deleted file mode 100644
index 19d21072c..000000000
--- a/test/fixture/es6-import.input.js
+++ /dev/null
@@ -1,11 +0,0 @@
-import hasEx6 from './es6-ext';
-import multiply from "./simple.input.js";
-import * as foo from "some-other-module";
-
-/**
- * This function returns the number one.
- * @returns {Number} numberone
- */
-var multiplyTwice = (a) => a * multiply(a);
-
-export default multiplyTwice;
diff --git a/test/fixture/es6-import.output.json b/test/fixture/es6-import.output.json
deleted file mode 100644
index 8388f25d0..000000000
--- a/test/fixture/es6-import.output.json
+++ /dev/null
@@ -1,420 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 9,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 43
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "name": "multiplyTwice",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "a",
- "lineNumber": 9
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "multiplyTwice",
- "kind": "function"
- }
- ],
- "namespace": "multiplyTwice"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is the default export frogs!",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 18
- }
- }
- },
- "errors": [],
- "name": "es6-ext",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "es6-ext"
- }
- ],
- "namespace": "es6-ext"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 2
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "simple.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "simple.input",
- "kind": "function"
- }
- ],
- "namespace": "simple.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/es6-import.output.md b/test/fixture/es6-import.output.md
deleted file mode 100644
index bea585d89..000000000
--- a/test/fixture/es6-import.output.md
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-# multiplyTwice
-
-This function returns the number one.
-
-**Parameters**
-
-- `a`
-
-Returns **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
-
-# es6-ext
-
-This is the default export frogs!
-
-# simple.input
-
-This function returns the number one.
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/es6-import.output.md.json b/test/fixture/es6-import.output.md.json
deleted file mode 100644
index eded2cef2..000000000
--- a/test/fixture/es6-import.output.md.json
+++ /dev/null
@@ -1,309 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "multiplyTwice"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "es6-ext"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is the default export frogs!",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "simple.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/es6.output.json b/test/fixture/es6.output.json
deleted file mode 100644
index 4e899117d..000000000
--- a/test/fixture/es6.output.json
+++ /dev/null
@@ -1,2614 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function destructures with defaults. It should not\nhave any parameter descriptions.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 33,
- "offset": 88
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 33,
- "offset": 88
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 33,
- "offset": 88
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "destructure",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "$0",
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "default": "{}",
- "properties": [
- {
- "title": "param",
- "name": "$0.phoneNumbers",
- "default": "[]"
- },
- {
- "title": "param",
- "name": "$0.emailAddresses",
- "default": "[]"
- },
- {
- "title": "param",
- "name": "$0.params",
- "lineNumber": 5,
- "type": {
- "type": "RestType"
- }
- }
- ]
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "destructure",
- "kind": "function"
- }
- ],
- "namespace": "destructure"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Similar, but with an array",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- }
- }
- },
- "tags": [
- {
- "title": "example",
- "description": "destructure([1, 2, 3])",
- "lineNumber": 2
- }
- ],
- "loc": {
- "start": {
- "line": 8,
- "column": 0
- },
- "end": {
- "line": 12,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 0
- },
- "end": {
- "line": 14,
- "column": 1
- }
- }
- },
- "errors": [],
- "examples": [
- {
- "description": "destructure([1, 2, 3])"
- }
- ],
- "name": "destructure",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "$0",
- "type": {
- "type": "NameExpression",
- "name": "Array"
- },
- "properties": [
- {
- "title": "param",
- "name": "$0.a",
- "lineNumber": 13
- },
- {
- "title": "param",
- "name": "$0.b",
- "lineNumber": 13
- },
- {
- "title": "param",
- "name": "$0.c",
- "lineNumber": 13
- }
- ]
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "destructure",
- "kind": "function"
- }
- ],
- "namespace": "destructure"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "an array of numbers",
- "lineNumber": 2,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Number"
- }
- ]
- },
- "name": "a"
- },
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 16,
- "column": 0
- },
- "end": {
- "line": 20,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 21,
- "column": 0
- },
- "end": {
- "line": 21,
- "column": 31
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "a",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "an array of numbers",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- }
- }
- },
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Number"
- }
- ]
- }
- },
- {
- "title": "param",
- "name": "b",
- "lineNumber": 21
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "name": "multiply",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "multiply",
- "kind": "function"
- }
- ],
- "namespace": "multiply"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a sink",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 23,
- "column": 0
- },
- "end": {
- "line": 25,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 26,
- "column": 0
- },
- "end": {
- "line": 62,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "Sink",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a property of the sink.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 27,
- "column": 2
- },
- "end": {
- "line": 29,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 30,
- "column": 2
- },
- "end": {
- "line": 30,
- "column": 18
- }
- }
- },
- "errors": [],
- "name": "staticProp",
- "kind": "member",
- "memberof": "Sink",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Sink",
- "kind": "class"
- },
- {
- "name": "staticProp",
- "kind": "member",
- "scope": "instance"
- }
- ],
- "namespace": "Sink#staticProp"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Is it empty",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 32,
- "column": 2
- },
- "end": {
- "line": 34,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 35,
- "column": 2
- },
- "end": {
- "line": 37,
- "column": 3
- }
- }
- },
- "errors": [],
- "name": "empty",
- "kind": "function",
- "memberof": "Sink",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Sink",
- "kind": "class"
- },
- {
- "name": "empty",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "Sink#empty"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a getter method: it should be documented\nas a property.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 15,
- "offset": 63
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 15,
- "offset": 63
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 15,
- "offset": 63
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 46,
- "column": 2
- },
- "end": {
- "line": 49,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 50,
- "column": 2
- },
- "end": {
- "line": 52,
- "column": 3
- }
- }
- },
- "errors": [],
- "name": "aGetter",
- "kind": "member",
- "memberof": "Sink",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Sink",
- "kind": "class"
- },
- {
- "name": "aGetter",
- "kind": "member",
- "scope": "instance"
- }
- ],
- "namespace": "Sink#aGetter"
- },
- {
- "description": "",
- "tags": [
- {
- "title": "param",
- "description": "the height of the thing",
- "lineNumber": 1,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "height"
- },
- {
- "title": "param",
- "description": "the width of the thing",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "width"
- }
- ],
- "loc": {
- "start": {
- "line": 54,
- "column": 2
- },
- "end": {
- "line": 57,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 58,
- "column": 2
- },
- "end": {
- "line": 61,
- "column": 3
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "height",
- "lineNumber": 1,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the height of the thing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "name": "width",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the width of the thing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "constructor",
- "kind": "function",
- "memberof": "Sink",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Sink",
- "kind": "class"
- },
- {
- "name": "constructor",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "Sink#constructor"
- }
- ],
- "static": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method says hello",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 39,
- "column": 2
- },
- "end": {
- "line": 41,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 42,
- "column": 2
- },
- "end": {
- "line": 44,
- "column": 3
- }
- }
- },
- "errors": [],
- "name": "hello",
- "kind": "function",
- "memberof": "Sink",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Sink",
- "kind": "class"
- },
- {
- "name": "hello",
- "kind": "function",
- "scope": "static"
- }
- ],
- "namespace": "Sink.hello"
- }
- ],
- "events": []
- },
- "path": [
- {
- "name": "Sink",
- "kind": "class"
- }
- ],
- "namespace": "Sink"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method returns a basket. The type should not be linked.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 61,
- "offset": 60
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 61,
- "offset": 60
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 61,
- "offset": 60
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "a basket",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "Basket"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 64,
- "column": 0
- },
- "end": {
- "line": 68,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 69,
- "column": 0
- },
- "end": {
- "line": 70,
- "column": 1
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "a basket",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Basket"
- }
- }
- ],
- "name": "makeABasket",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "makeABasket",
- "kind": "function"
- }
- ],
- "namespace": "makeABasket"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method returns a ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- },
- {
- "type": "link",
- "url": "Sink",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "sink"
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ". The type should be linked.\nIt takes a ",
- "position": {
- "start": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "end": {
- "line": 2,
- "column": 12,
- "offset": 79
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "link",
- "url": "number",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ],
- "position": {
- "start": {
- "line": 2,
- "column": 12,
- "offset": 79
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 93
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " which should also be linked.",
- "position": {
- "start": {
- "line": 2,
- "column": 26,
- "offset": 93
- },
- "end": {
- "line": 2,
- "column": 55,
- "offset": 122
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 55,
- "offset": 122
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 55,
- "offset": 122
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "a sink",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Sink"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 72,
- "column": 0
- },
- "end": {
- "line": 77,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 78,
- "column": 0
- },
- "end": {
- "line": 79,
- "column": 1
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "a sink",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Sink"
- }
- }
- ],
- "name": "makeASink",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "makeASink",
- "kind": "function"
- }
- ],
- "namespace": "makeASink"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function takes rest params",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 81,
- "column": 0
- },
- "end": {
- "line": 83,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 84,
- "column": 0
- },
- "end": {
- "line": 85,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "functionWithRest",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "someParams",
- "lineNumber": 84,
- "type": {
- "type": "RestType"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "functionWithRest",
- "kind": "function"
- }
- ],
- "namespace": "functionWithRest"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "So does this one, with types",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 87,
- "column": 0
- },
- "end": {
- "line": 89,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 90,
- "column": 0
- },
- "end": {
- "line": 91,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "functionWithRestAndType",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "someParams",
- "lineNumber": 90,
- "type": {
- "type": "RestType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "functionWithRestAndType",
- "kind": "function"
- }
- ],
- "namespace": "functionWithRestAndType"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is an async method",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 95,
- "column": 0
- },
- "end": {
- "line": 97,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 98,
- "column": 0
- },
- "end": {
- "line": 98,
- "column": 24
- }
- }
- },
- "errors": [],
- "name": "foo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo",
- "kind": "function"
- }
- ],
- "namespace": "foo"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 102,
- "column": 0
- },
- "end": {
- "line": 105,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 106,
- "column": 0
- },
- "end": {
- "line": 106,
- "column": 38
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "name": "es6.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "es6.input",
- "kind": "function"
- }
- ],
- "namespace": "es6.input"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of optional parameters in ES6",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 108,
- "column": 0
- },
- "end": {
- "line": 110,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 111,
- "column": 0
- },
- "end": {
- "line": 113,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "veryImportantTransform",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "foo",
- "default": "'bar'"
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "veryImportantTransform",
- "kind": "function"
- }
- ],
- "namespace": "veryImportantTransform"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A protected function",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- }
- }
- },
- "tags": [
- {
- "title": "protected",
- "description": null,
- "lineNumber": 2
- }
- ],
- "loc": {
- "start": {
- "line": 123,
- "column": 0
- },
- "end": {
- "line": 126,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 127,
- "column": 0
- },
- "end": {
- "line": 127,
- "column": 27
- }
- }
- },
- "errors": [],
- "access": "protected",
- "name": "iAmProtected",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "iAmProtected",
- "kind": "function"
- }
- ],
- "namespace": "iAmProtected"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A public function",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- }
- }
- },
- "tags": [
- {
- "title": "public",
- "description": null,
- "lineNumber": 2
- }
- ],
- "loc": {
- "start": {
- "line": 129,
- "column": 0
- },
- "end": {
- "line": 132,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 133,
- "column": 0
- },
- "end": {
- "line": 133,
- "column": 24
- }
- }
- },
- "errors": [],
- "access": "public",
- "name": "iAmPublic",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "iAmPublic",
- "kind": "function"
- }
- ],
- "namespace": "iAmPublic"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is re-exported",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 141,
- "column": 0
- },
- "end": {
- "line": 143,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 144,
- "column": 0
- },
- "end": {
- "line": 144,
- "column": 42
- }
- }
- },
- "errors": [],
- "name": "execute",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "execute"
- }
- ],
- "namespace": "execute"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Regression check for #498",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 146,
- "column": 0
- },
- "end": {
- "line": 146,
- "column": 32
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 147,
- "column": 0
- },
- "end": {
- "line": 153,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "isArrayEqualWith",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "array1",
- "lineNumber": 148,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "T"
- }
- ]
- }
- },
- {
- "title": "param",
- "name": "array2",
- "lineNumber": 149,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "T"
- }
- ]
- }
- },
- {
- "title": "param",
- "name": "compareFunction",
- "default": "(a: T, b: T): boolean => a === b",
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "FunctionType",
- "params": [
- {
- "type": "ParameterType",
- "name": "a",
- "expression": {
- "type": "NameExpression",
- "name": "T"
- }
- },
- {
- "type": "ParameterType",
- "name": "b",
- "expression": {
- "type": "NameExpression",
- "name": "T"
- }
- }
- ],
- "result": {
- "type": "NameExpression",
- "name": "boolean"
- }
- }
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "isArrayEqualWith",
- "kind": "function"
- }
- ],
- "namespace": "isArrayEqualWith"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/es6.output.md.json b/test/fixture/es6.output.md.json
deleted file mode 100644
index 512fd2610..000000000
--- a/test/fixture/es6.output.md.json
+++ /dev/null
@@ -1,2233 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "destructure"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function destructures with defaults. It should not\nhave any parameter descriptions.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 33,
- "offset": 88
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 33,
- "offset": 88
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "{}"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.phoneNumbers"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "[]"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.emailAddresses"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "[]"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.params"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "..."
- },
- {
- "type": "text",
- "value": "any"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "destructure"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Similar, but with an array",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.b"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.c"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Examples"
- }
- ]
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "destructure([1, 2, 3])"
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "multiply"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "an array of numbers",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "b"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Sink"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a sink",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "staticProp"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a property of the sink.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "empty"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Is it empty",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "aGetter"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a getter method: it should be documented\nas a property.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 15,
- "offset": 63
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 15,
- "offset": 63
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "constructor"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "height"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the height of the thing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "width"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the width of the thing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "hello"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method says hello",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "makeABasket"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method returns a basket. The type should not be linked.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 61,
- "offset": 60
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 61,
- "offset": 60
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Basket"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "a basket",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "makeASink"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method returns a ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- },
- {
- "type": "link",
- "url": "#sink",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "sink"
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ". The type should be linked.\nIt takes a ",
- "position": {
- "start": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "end": {
- "line": 2,
- "column": 12,
- "offset": 79
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "link",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ],
- "position": {
- "start": {
- "line": 2,
- "column": 12,
- "offset": 79
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 93
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " which should also be linked.",
- "position": {
- "start": {
- "line": 2,
- "column": 26,
- "offset": 93
- },
- "end": {
- "line": 2,
- "column": 55,
- "offset": 122
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 55,
- "offset": 122
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "#sink",
- "url": "#sink",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Sink"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "a sink",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "functionWithRest"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function takes rest params",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "someParams"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "..."
- },
- {
- "type": "text",
- "value": "any"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "functionWithRestAndType"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "So does this one, with types",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "someParams"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "..."
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is an async method",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "es6.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "veryImportantTransform"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of optional parameters in ES6",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "foo"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "'bar'"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "iAmProtected"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A protected function",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "iAmPublic"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A public function",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "execute"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is re-exported",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 20,
- "offset": 19
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "isArrayEqualWith"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Regression check for #498",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "array1"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "type": "text",
- "value": "T"
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "array2"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "type": "text",
- "value": "T"
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "compareFunction"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "function ("
- },
- {
- "type": "text",
- "value": "a: "
- },
- {
- "type": "text",
- "value": "T"
- },
- {
- "type": "text",
- "value": ", "
- },
- {
- "type": "text",
- "value": "b: "
- },
- {
- "type": "text",
- "value": "T"
- },
- {
- "type": "text",
- "value": ")"
- },
- {
- "type": "text",
- "value": ": "
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "boolean"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "(a: T, b: T): boolean => a === b"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "boolean"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/event.output.json b/test/fixture/event.output.json
deleted file mode 100644
index 934cbf267..000000000
--- a/test/fixture/event.output.json
+++ /dev/null
@@ -1,250 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Mouse event",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- }
- }
- },
- "tags": [
- {
- "title": "event",
- "description": "Map#mousemove",
- "lineNumber": 3
- },
- {
- "title": "type",
- "description": null,
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- {
- "title": "property",
- "description": "the pixel location of the event",
- "lineNumber": 5,
- "type": {
- "type": "NameExpression",
- "name": "Point"
- },
- "name": "point"
- },
- {
- "title": "property",
- "description": "the original DOM event",
- "lineNumber": 6,
- "type": {
- "type": "NameExpression",
- "name": "Event"
- },
- "name": "originalEvent"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 0
- }
- }
- },
- "errors": [],
- "kind": "event",
- "name": "Map#mousemove",
- "properties": [
- {
- "name": "point",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the pixel location of the event",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Point"
- }
- },
- {
- "name": "originalEvent",
- "lineNumber": 6,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the original DOM event",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Event"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Map#mousemove",
- "kind": "event"
- }
- ],
- "namespace": ".event:Map#mousemove"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/event.output.md b/test/fixture/event.output.md
deleted file mode 100644
index 7ef8b9ff9..000000000
--- a/test/fixture/event.output.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-# Map#mousemove
-
-Mouse event
-
-**Properties**
-
-- `point` **Point** the pixel location of the event
-- `originalEvent` **[Event](https://developer.mozilla.org/en-US/docs/Web/API/Event)** the original DOM event
diff --git a/test/fixture/event.output.md.json b/test/fixture/event.output.md.json
deleted file mode 100644
index f4902ed49..000000000
--- a/test/fixture/event.output.md.json
+++ /dev/null
@@ -1,208 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Map#mousemove"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Mouse event",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "point"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Point"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the pixel location of the event",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "originalEvent"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/API/Event",
- "url": "https://developer.mozilla.org/en-US/docs/Web/API/Event",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Event"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the original DOM event",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/example-caption.output.json b/test/fixture/example-caption.output.json
deleted file mode 100644
index 1a9091b06..000000000
--- a/test/fixture/example-caption.output.json
+++ /dev/null
@@ -1,226 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- {
- "title": "example",
- "description": "foo(1);",
- "lineNumber": 3,
- "caption": "demonstrates how to run foo"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 10,
- "column": 1
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "examples": [
- {
- "description": "foo(1);",
- "caption": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "demonstrates how to run foo",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- }
- }
- }
- }
- ],
- "name": "foo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo",
- "kind": "function"
- }
- ],
- "namespace": "foo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/example-caption.output.md b/test/fixture/example-caption.output.md
deleted file mode 100644
index ca436eccd..000000000
--- a/test/fixture/example-caption.output.md
+++ /dev/null
@@ -1,15 +0,0 @@
-
-
-# foo
-
-This function returns the number one.
-
-**Examples**
-
-_demonstrates how to run foo_
-
-```javascript
-foo(1);
-```
-
-Returns **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/example-caption.output.md.json b/test/fixture/example-caption.output.md.json
deleted file mode 100644
index 454136a7e..000000000
--- a/test/fixture/example-caption.output.md.json
+++ /dev/null
@@ -1,189 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Examples"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "emphasis",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "demonstrates how to run foo",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- }
- }
- }
- ]
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "foo(1);"
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/external.output.json b/test/fixture/external.output.json
deleted file mode 100644
index 929a6a4c4..000000000
--- a/test/fixture/external.output.json
+++ /dev/null
@@ -1,127 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "I am in ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "external.input.js",
- "position": {
- "start": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 13,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "foo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo",
- "kind": "function"
- }
- ],
- "namespace": "foo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/external.output.md b/test/fixture/external.output.md
deleted file mode 100644
index 44bc64403..000000000
--- a/test/fixture/external.output.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-# foo
-
-I am in `external.input.js`.
diff --git a/test/fixture/external.output.md.json b/test/fixture/external.output.md.json
deleted file mode 100644
index f7b9d2962..000000000
--- a/test/fixture/external.output.md.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "I am in ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "external.input.js",
- "position": {
- "start": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/factory.output.json b/test/fixture/factory.output.json
deleted file mode 100644
index 4b9d07561..000000000
--- a/test/fixture/factory.output.json
+++ /dev/null
@@ -1,331 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "an area chart generator",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "chart",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "area"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 21,
- "column": 2
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "chart",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 6,
- "offset": 5
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 6,
- "offset": 5
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 6,
- "offset": 5
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "area"
- }
- }
- ],
- "name": "area",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "area",
- "kind": "function"
- }
- ],
- "namespace": "area"
- },
- {
- "description": "",
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 1,
- "type": null,
- "name": "area"
- }
- ],
- "loc": {
- "start": {
- "line": 7,
- "column": 2
- },
- "end": {
- "line": 9,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 2
- },
- "end": {
- "line": 11,
- "column": 4
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "area",
- "params": [
- {
- "title": "param",
- "name": "selection",
- "lineNumber": 10
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "area",
- "kind": "class"
- }
- ],
- "namespace": "area"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Sets the chart data.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- }
- }
- },
- "tags": [
- {
- "title": "function",
- "description": null,
- "lineNumber": 2,
- "name": null
- }
- ],
- "loc": {
- "start": {
- "line": 13,
- "column": 2
- },
- "end": {
- "line": 16,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 17,
- "column": 2
- },
- "end": {
- "line": 18,
- "column": 4
- }
- }
- },
- "errors": [
- {
- "message": "@memberof reference to chart not found",
- "commentLineNumber": 0
- }
- ],
- "kind": "function",
- "name": "data",
- "params": [
- {
- "title": "param",
- "name": "_",
- "lineNumber": 17
- }
- ],
- "memberof": "chart",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "data",
- "kind": "function",
- "scope": "static"
- }
- ],
- "namespace": ".data"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/factory.output.md b/test/fixture/factory.output.md
deleted file mode 100644
index 8447aea0e..000000000
--- a/test/fixture/factory.output.md
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-# area
-
-an area chart generator
-
-Returns **[area](#area)** chart
-
-# area
-
-**Parameters**
-
-- `selection`
-
-# data
-
-Sets the chart data.
-
-**Parameters**
-
-- `_`
diff --git a/test/fixture/factory.output.md.json b/test/fixture/factory.output.md.json
deleted file mode 100644
index f0927c235..000000000
--- a/test/fixture/factory.output.md.json
+++ /dev/null
@@ -1,247 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "area"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "an area chart generator",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "#area",
- "url": "#area",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "area"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "chart",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 6,
- "offset": 5
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 6,
- "offset": 5
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "area"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "selection"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "data"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Sets the chart data.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "_"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/html/nested.config-output.html b/test/fixture/html/nested.config-output.html
deleted file mode 100644
index 470ecf382..000000000
--- a/test/fixture/html/nested.config-output.html
+++ /dev/null
@@ -1,1307 +0,0 @@
-
-
-
- | Documentation
-
-
-
-
-
-
-
-
-
- Highlighted section
-
-
-
- The public key is a base64 encoded string of a protobuf containing an RSA DER
-buffer. This uses a node buffer to pass the base64 encoded public key protobuf
-to the multihash for ID generation.
-var PeerId = require ('peer-id' )
-
-PeerId.create({ bits : 1024 }, (err, id) => {
- console .log(JSON .stringify(id.toJSON(), null , 2 )
-}){
- "id": "Qma9T5YraSnpRDZqRR4krcSJabThc8nwZuJV3LercPHufi",
- "privKey": "CAAS4AQwggJcAgEAAoGBAMBgbIqyOL26oV3nGPBYrdpbv..",
- "pubKey": "CAASogEwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMBgbIqyOL26oV3nGPBYrdpbvzCY..."
-}
-
-
-
-
-
-
-
-
-
-
-
- Klass
-
-
-
-
-
-
- Creates a new Klass
-
-
- new Klass(foo: any)
-
-
-
- Extends
-
- Stream.Writable
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
-
-
-
-
-
-
-
-
- Static Members
-
-
-
-
-
-
▸
-
isClass(other, also)
-
-
-
-
-
-
-
- Decide whether an object is a Klass instance
-This is a [klasssic]Klass
-This is a [link to something that does not exist]DoesNot
-
-
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
-
-
-
- Returns
- boolean
-
-
-
-
-
-
-
-
-
-
-
- A function that triggers the case where the autolinker doesn't find
-the referenced class type
-
-
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
- other (Weird)
-
-
-
-
-
-
Returns
- boolean
-
-
-
-
-
-
-
-
▸
-
isBuffer(buf, size = 0)
-
-
-
-
-
-
-
- This method takes a Buffer object that will be linked to nodejs.org
-
-
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
-
-
-
size (number ?
- = 0)
- size
-
-
-
-
-
-
Returns
- boolean
-
-
-
-
-
-
-
-
▸
-
isArrayOfBuffers(buffers)
-
-
-
-
-
-
-
- This method takes an array of buffers and counts them
-
-
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
-
-
-
- Returns
- number Example
-
-
- var k = new Klass();
-k.isArrayOfBuffers();
-
-
-
-
-
-
-
-
-
-
-
- A magic number that identifies this Klass.
-
-
- MAGIC_NUMBER
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Klass event
-
-
- event
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Instance Members
-
-
-
-
-
-
-
-
-
- Get this Klass's foo
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Returns
- Number Example
-
-
this shows you how to getFoo
-
- var x = foo.getFoo();
-
-
-
-
-
-
-
-
▸
-
withOptions(options, otherOptions)
-
-
-
-
-
-
-
- A function with an options parameter
-
-
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
-
-
-
-
-
-
- Name
- Description
-
-
-
-
-
- options.foo string
-
-
- options.bar number
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- CustomError
-
-
-
-
-
-
- a typedef with nested properties
-
-
- CustomError
-
-
-
-
-
-
-
-
-
-
-
-
- Properties
-
-
-
-
error (object )
- : An error
-
-
-
-
- error.code string
-
- The error's code
-error.description string
-
- The error's description
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- bar
-
-
-
-
-
-
- Get an instance of Klass . Will make
-a klass instance multiword ,
-like a klass
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Returns
- Klass
-
-
-
-
-
-
-
-
-
-
- bar
-
-
-
-
-
-
- Rest property function
-
-
-
-
-
-
-
-
-
-
-
-
-
- Parameters
-
-
-
-
-
-
-
- Returns
- undefined
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Foo
-
-
-
-
-
-
- This is Foo
-
-
- new Foo()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Instance Members
-
-
-
-
-
-
-
-
-
- This is bar
-
-
- bar
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- customStreams
-
-
-
-
-
-
- I am the container of stream types
-
-
- customStreams
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Static Members
-
-
-
-
-
-
▸
-
new passthrough()
-
-
-
-
-
-
-
- I am a passthrough stream that belongs to customStreams
-
-
- new passthrough()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-This link refers to nothing: [nothing](nothing)
-
-**Parameters**
-
-- `a` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** the input
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/inline-link.output.md.json b/test/fixture/inline-link.output.md.json
deleted file mode 100644
index 22cf26b50..000000000
--- a/test/fixture/inline-link.output.md.json
+++ /dev/null
@@ -1,582 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "addOne"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Adds one to a number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the input",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the output",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "inline-link.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one. Internally, this uses\n",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 1,
- "offset": 60
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "link",
- "url": "#addone",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "addOne"
- }
- ],
- "position": {
- "start": {
- "line": 2,
- "column": 1,
- "offset": 60
- },
- "end": {
- "line": 2,
- "column": 15,
- "offset": 74
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " to do the math. This demonstrates\n",
- "position": {
- "start": {
- "line": 2,
- "column": 15,
- "offset": 74
- },
- "end": {
- "line": 3,
- "column": 1,
- "offset": 109
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "link",
- "url": "https://en.wikipedia.org/wiki/Addition",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "Addition"
- }
- ],
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 109
- },
- "end": {
- "line": 3,
- "column": 56,
- "offset": 164
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": "\nand ",
- "position": {
- "start": {
- "line": 3,
- "column": 56,
- "offset": 164
- },
- "end": {
- "line": 4,
- "column": 5,
- "offset": 169
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "link",
- "url": "https://en.wikipedia.org/wiki/Addition",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "https://en.wikipedia.org/wiki/Addition"
- }
- ],
- "position": {
- "start": {
- "line": 4,
- "column": 5,
- "offset": 169
- },
- "end": {
- "line": 4,
- "column": 51,
- "offset": 215
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 4,
- "column": 51,
- "offset": 215
- },
- "indent": [
- 1,
- 1,
- 1
- ]
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This link refers to nothing: ",
- "position": {
- "start": {
- "line": 6,
- "column": 1,
- "offset": 217
- },
- "end": {
- "line": 6,
- "column": 30,
- "offset": 246
- },
- "indent": []
- }
- },
- {
- "type": "link",
- "url": "nothing",
- "title": null,
- "jsdoc": true,
- "children": [
- {
- "type": "text",
- "value": "nothing"
- }
- ],
- "position": {
- "start": {
- "line": 6,
- "column": 30,
- "offset": 246
- },
- "end": {
- "line": 6,
- "column": 45,
- "offset": 261
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 6,
- "column": 1,
- "offset": 217
- },
- "end": {
- "line": 6,
- "column": 45,
- "offset": 261
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the input",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/internal.output.json b/test/fixture/internal.output.json
deleted file mode 100644
index 929a6a4c4..000000000
--- a/test/fixture/internal.output.json
+++ /dev/null
@@ -1,127 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "I am in ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "external.input.js",
- "position": {
- "start": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 13,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "foo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo",
- "kind": "function"
- }
- ],
- "namespace": "foo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/internal.output.md b/test/fixture/internal.output.md
deleted file mode 100644
index 44bc64403..000000000
--- a/test/fixture/internal.output.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-# foo
-
-I am in `external.input.js`.
diff --git a/test/fixture/internal.output.md.json b/test/fixture/internal.output.md.json
deleted file mode 100644
index f7b9d2962..000000000
--- a/test/fixture/internal.output.md.json
+++ /dev/null
@@ -1,88 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "I am in ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "external.input.js",
- "position": {
- "start": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/lint/lint.output.js b/test/fixture/lint/lint.output.js
deleted file mode 100644
index 4725962b4..000000000
--- a/test/fixture/lint/lint.output.js
+++ /dev/null
@@ -1,12 +0,0 @@
- 2:1 warning type String found, string is standard
- 3:1 warning type Number found, number is standard
- 4:1 warning type Number found, number is standard
- 5:1 warning type Number found, number is standard
- 6:1 warning type object found, Object is standard
- 7:1 warning type object found, Object is standard
- 8:1 warning @memberof reference to notfound not found
- 11:1 warning could not determine @name for hierarchy
- 12:1 warning type String found, string is standard
- 13:1 warning type String found, string is standard
-
-⚠ 11 warnings
diff --git a/test/fixture/literal_types.output.json b/test/fixture/literal_types.output.json
deleted file mode 100644
index 2aa36d096..000000000
--- a/test/fixture/literal_types.output.json
+++ /dev/null
@@ -1,189 +0,0 @@
-[
- {
- "description": "",
- "tags": [
- {
- "title": "param",
- "description": null,
- "lineNumber": 1,
- "type": {
- "type": "UnionType",
- "elements": [
- {
- "type": "StringLiteralType",
- "value": "a"
- },
- {
- "type": "StringLiteralType",
- "value": "b"
- },
- {
- "type": "StringLiteralType",
- "value": ""
- },
- {
- "type": "NumericLiteralType",
- "value": 0
- },
- {
- "type": "NumericLiteralType",
- "value": -42
- },
- {
- "type": "NumericLiteralType",
- "value": 3.14
- }
- ]
- },
- "name": "x"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 16
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "x",
- "lineNumber": 1,
- "type": {
- "type": "UnionType",
- "elements": [
- {
- "type": "StringLiteralType",
- "value": "a"
- },
- {
- "type": "StringLiteralType",
- "value": "b"
- },
- {
- "type": "StringLiteralType",
- "value": ""
- },
- {
- "type": "NumericLiteralType",
- "value": 0
- },
- {
- "type": "NumericLiteralType",
- "value": -42
- },
- {
- "type": "NumericLiteralType",
- "value": 3.14
- }
- ]
- }
- }
- ],
- "name": "f",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f",
- "kind": "function"
- }
- ],
- "namespace": "f"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 6,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 49
- }
- }
- },
- "errors": [],
- "name": "g",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "x",
- "lineNumber": 7,
- "type": {
- "type": "UnionType",
- "elements": [
- {
- "type": "StringLiteralType",
- "value": "a"
- },
- {
- "type": "StringLiteralType",
- "value": "b"
- },
- {
- "type": "StringLiteralType",
- "value": ""
- },
- {
- "type": "NumericLiteralType",
- "value": 0
- },
- {
- "type": "NumericLiteralType",
- "value": -42
- },
- {
- "type": "NumericLiteralType",
- "value": 3.14
- }
- ]
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "g",
- "kind": "function"
- }
- ],
- "namespace": "g"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/literal_types.output.md b/test/fixture/literal_types.output.md
deleted file mode 100644
index 74753d495..000000000
--- a/test/fixture/literal_types.output.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-
-# f
-
-**Parameters**
-
-- `x` **(`"a"` \| `"b"` \| `""` \| `0` \| `-42` \| `3.14`)**
-
-# g
-
-**Parameters**
-
-- `x` **(`"a"` \| `"b"` \| `""` \| `0` \| `-42` \| `3.14`)**
diff --git a/test/fixture/literal_types.output.md.json b/test/fixture/literal_types.output.md.json
deleted file mode 100644
index 73c1d7f7d..000000000
--- a/test/fixture/literal_types.output.md.json
+++ /dev/null
@@ -1,217 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "("
- },
- {
- "type": "inlineCode",
- "value": "\"a\""
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "\"b\""
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "\"\""
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "0"
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "-42"
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "3.14"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "g"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "("
- },
- {
- "type": "inlineCode",
- "value": "\"a\""
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "\"b\""
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "\"\""
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "0"
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "-42"
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "type": "inlineCode",
- "value": "3.14"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/memberedclass.output.json b/test/fixture/memberedclass.output.json
deleted file mode 100644
index 2a10d55f5..000000000
--- a/test/fixture/memberedclass.output.json
+++ /dev/null
@@ -1,521 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is my class, a demo thing.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- }
- }
- },
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 3,
- "type": null,
- "name": "MyClass"
- },
- {
- "title": "memberof",
- "description": "com.Test",
- "lineNumber": 4
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 29,
- "column": 2
- }
- }
- },
- "errors": [
- {
- "message": "@memberof reference to com.Test not found",
- "commentLineNumber": 4
- }
- ],
- "kind": "class",
- "name": "MyClass",
- "memberof": "com.Test",
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get the number 42",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "whether to get the number",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- },
- "name": "getIt"
- },
- {
- "title": "returns",
- "description": "forty-two",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 13,
- "column": 4
- },
- "end": {
- "line": 18,
- "column": 7
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 19,
- "column": 4
- },
- "end": {
- "line": 21,
- "column": 5
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "getIt",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "whether to get the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "forty-two",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "getFoo",
- "kind": "function",
- "memberof": "com.Test.MyClass",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "MyClass",
- "kind": "class"
- },
- {
- "name": "getFoo",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "MyClass#getFoo"
- }
- ],
- "static": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get undefined",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "does not return anything.",
- "lineNumber": 3,
- "type": {
- "type": "UndefinedLiteral"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 23,
- "column": 4
- },
- "end": {
- "line": 27,
- "column": 7
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 28,
- "column": 4
- },
- "end": {
- "line": 28,
- "column": 28
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "does not return anything.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- }
- }
- },
- "type": {
- "type": "UndefinedLiteral"
- }
- }
- ],
- "name": "getUndefined",
- "kind": "function",
- "memberof": "com.Test.MyClass",
- "scope": "static",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "MyClass",
- "kind": "class"
- },
- {
- "name": "getUndefined",
- "kind": "function",
- "scope": "static"
- }
- ],
- "namespace": "MyClass.getUndefined"
- }
- ],
- "events": []
- },
- "path": [
- {
- "name": "MyClass",
- "kind": "class"
- }
- ],
- "namespace": "MyClass"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/memberedclass.output.md b/test/fixture/memberedclass.output.md
deleted file mode 100644
index 9eb73392d..000000000
--- a/test/fixture/memberedclass.output.md
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-# MyClass
-
-This is my class, a demo thing.
-
-## getFoo
-
-Get the number 42
-
-**Parameters**
-
-- `getIt` **[boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** whether to get the number
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** forty-two
-
-## getUndefined
-
-Get undefined
-
-Returns **[undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)** does not return anything.
diff --git a/test/fixture/memberedclass.output.md.json b/test/fixture/memberedclass.output.md.json
deleted file mode 100644
index 418fc5ab1..000000000
--- a/test/fixture/memberedclass.output.md.json
+++ /dev/null
@@ -1,360 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "MyClass"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is my class, a demo thing.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getFoo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get the number 42",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 18,
- "offset": 17
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "getIt"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "boolean"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "whether to get the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "forty-two",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getUndefined"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get undefined",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 14,
- "offset": 13
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "undefined"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "does not return anything.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/merge-infered-type.output.json b/test/fixture/merge-infered-type.output.json
deleted file mode 100644
index 74112ac39..000000000
--- a/test/fixture/merge-infered-type.output.json
+++ /dev/null
@@ -1,263 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Add five to ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "x",
- "position": {
- "start": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "The number to add five to.",
- "lineNumber": 3,
- "type": null,
- "name": "x"
- },
- {
- "title": "returns",
- "description": "x plus five.",
- "lineNumber": 4,
- "type": null
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "x",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The number to add five to.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "x plus five.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "addFive",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "addFive",
- "kind": "function"
- }
- ],
- "namespace": "addFive"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/merge-infered-type.output.md b/test/fixture/merge-infered-type.output.md
deleted file mode 100644
index c64aef0e9..000000000
--- a/test/fixture/merge-infered-type.output.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-# addFive
-
-Add five to `x`.
-
-**Parameters**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** The number to add five to.
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** x plus five.
diff --git a/test/fixture/merge-infered-type.output.md.json b/test/fixture/merge-infered-type.output.md.json
deleted file mode 100644
index 45d45042d..000000000
--- a/test/fixture/merge-infered-type.output.md.json
+++ /dev/null
@@ -1,240 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "addFive"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Add five to ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "x",
- "position": {
- "start": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The number to add five to.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "x plus five.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/multisignature.output.json b/test/fixture/multisignature.output.json
deleted file mode 100644
index 677c1b968..000000000
--- a/test/fixture/multisignature.output.json
+++ /dev/null
@@ -1,401 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get the time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "the current date",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Date"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 0
- },
- "end": {
- "line": 19,
- "column": 1
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the current date",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Date"
- }
- }
- ],
- "name": "getTheTime",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "time",
- "lineNumber": 13
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "getTheTime",
- "kind": "function"
- }
- ],
- "namespace": "getTheTime"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Set the time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "the current time",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Date"
- },
- "name": "time"
- },
- {
- "title": "returns",
- "description": "nothing",
- "lineNumber": 3,
- "type": {
- "type": "UndefinedLiteral"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 8,
- "column": 0
- },
- "end": {
- "line": 12,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 0
- },
- "end": {
- "line": 19,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "time",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the current time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Date"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "nothing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- }
- }
- },
- "type": {
- "type": "UndefinedLiteral"
- }
- }
- ],
- "name": "getTheTime",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "getTheTime",
- "kind": "function"
- }
- ],
- "namespace": "getTheTime"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/multisignature.output.md b/test/fixture/multisignature.output.md
deleted file mode 100644
index 35fdd1d86..000000000
--- a/test/fixture/multisignature.output.md
+++ /dev/null
@@ -1,21 +0,0 @@
-
-
-# getTheTime
-
-Get the time
-
-**Parameters**
-
-- `time`
-
-Returns **[Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)** the current date
-
-# getTheTime
-
-Set the time
-
-**Parameters**
-
-- `time` **[Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date)** the current time
-
-Returns **[undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)** nothing
diff --git a/test/fixture/multisignature.output.md.json b/test/fixture/multisignature.output.md.json
deleted file mode 100644
index d3b1f7b4d..000000000
--- a/test/fixture/multisignature.output.md.json
+++ /dev/null
@@ -1,352 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getTheTime"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Get the time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "time"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Date"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the current date",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "getTheTime"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Set the time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "time"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Date"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the current time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "undefined"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "nothing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/nearby_params.output.json b/test/fixture/nearby_params.output.json
deleted file mode 100644
index ccb5eb9f6..000000000
--- a/test/fixture/nearby_params.output.json
+++ /dev/null
@@ -1,515 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Attempt to establish a cookie-based session in exchange for credentials.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 73,
- "offset": 72
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 73,
- "offset": 72
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 73,
- "offset": 72
- }
- }
- },
- "tags": [
- {
- "title": "function",
- "description": null,
- "lineNumber": 1,
- "name": null
- },
- {
- "title": "name",
- "description": null,
- "lineNumber": 2,
- "name": "sessions.create"
- },
- {
- "title": "param",
- "description": null,
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "object"
- },
- "name": "credentials"
- },
- {
- "title": "param",
- "description": "Login username. Also accepted as `username` or `email`.",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "credentials.name"
- },
- {
- "title": "param",
- "description": "Login password",
- "lineNumber": 5,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "credentials.password"
- },
- {
- "title": "param",
- "description": "Gets passed `(err, { success:Boolean })`.",
- "lineNumber": 6,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "function"
- }
- },
- "name": "callback"
- },
- {
- "title": "returns",
- "description": "promise, to be resolved on success or rejected on failure",
- "lineNumber": 7,
- "type": {
- "type": "NameExpression",
- "name": "Promise"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 14,
- "column": 3
- }
- }
- },
- "errors": [],
- "kind": "function",
- "name": "sessions.create",
- "params": [
- {
- "name": "credentials",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "object"
- },
- "properties": [
- {
- "name": "credentials.name",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Login username. Also accepted as ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "username",
- "position": {
- "start": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "end": {
- "line": 1,
- "column": 44,
- "offset": 43
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " or ",
- "position": {
- "start": {
- "line": 1,
- "column": 44,
- "offset": 43
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "email",
- "position": {
- "start": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "end": {
- "line": 1,
- "column": 56,
- "offset": 55
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 56,
- "offset": 55
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 56,
- "offset": 55
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- },
- {
- "name": "credentials.password",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Login password",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ]
- },
- {
- "name": "callback",
- "lineNumber": 6,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Gets passed ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "(err, { success:Boolean })",
- "position": {
- "start": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "end": {
- "line": 1,
- "column": 41,
- "offset": 40
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 41,
- "offset": 40
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "function"
- }
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "promise, to be resolved on success or rejected on failure",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 58,
- "offset": 57
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 58,
- "offset": 57
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 58,
- "offset": 57
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Promise"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "sessions.create",
- "kind": "function"
- }
- ],
- "namespace": "sessions.create"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/nearby_params.output.md b/test/fixture/nearby_params.output.md
deleted file mode 100644
index 46a8965a8..000000000
--- a/test/fixture/nearby_params.output.md
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-# sessions.create
-
-Attempt to establish a cookie-based session in exchange for credentials.
-
-**Parameters**
-
-- `credentials` **[object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)**
- - `credentials.name` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Login username. Also accepted as `username` or `email`.
- - `credentials.password` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Login password
-- `callback` **[function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)?** Gets passed `(err, { success:Boolean })`.
-
-Returns **[Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)** promise, to be resolved on success or rejected on failure
diff --git a/test/fixture/nearby_params.output.md.json b/test/fixture/nearby_params.output.md.json
deleted file mode 100644
index 42df8b139..000000000
--- a/test/fixture/nearby_params.output.md.json
+++ /dev/null
@@ -1,502 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "sessions.create"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Attempt to establish a cookie-based session in exchange for credentials.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 73,
- "offset": 72
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 73,
- "offset": 72
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "credentials"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "credentials.name"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Login username. Also accepted as ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "username",
- "position": {
- "start": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "end": {
- "line": 1,
- "column": 44,
- "offset": 43
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " or ",
- "position": {
- "start": {
- "line": 1,
- "column": 44,
- "offset": 43
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "email",
- "position": {
- "start": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "end": {
- "line": 1,
- "column": 56,
- "offset": 55
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 56,
- "offset": 55
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "credentials.password"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Login password",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "callback"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "function"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Gets passed ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "(err, { success:Boolean })",
- "position": {
- "start": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "end": {
- "line": 1,
- "column": 41,
- "offset": 40
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": ".",
- "position": {
- "start": {
- "line": 1,
- "column": 41,
- "offset": 40
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Promise"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "promise, to be resolved on success or rejected on failure",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 58,
- "offset": 57
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 58,
- "offset": 57
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/nest_params.output.json b/test/fixture/nest_params.output.json
deleted file mode 100644
index 0fd39a47e..000000000
--- a/test/fixture/nest_params.output.json
+++ /dev/null
@@ -1,809 +0,0 @@
-[
- {
- "description": "",
- "tags": [
- {
- "title": "param",
- "description": "The employees who are responsible for the project.",
- "lineNumber": 1,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Object"
- }
- ]
- },
- "name": "employees"
- },
- {
- "title": "param",
- "description": "The name of an employee.",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "employees[].name"
- },
- {
- "title": "param",
- "description": "The employee's department.",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "employees[].department"
- },
- {
- "title": "param",
- "description": "The employee's type.",
- "lineNumber": 4,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "string"
- }
- },
- "name": "type",
- "default": "minion"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "employees",
- "lineNumber": 1,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The employees who are responsible for the project.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 51,
- "offset": 50
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 51,
- "offset": 50
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 51,
- "offset": 50
- }
- }
- },
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Object"
- }
- ]
- },
- "properties": [
- {
- "name": "employees[].name",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The name of an employee.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- },
- {
- "name": "employees[].department",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The employee's department.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ]
- },
- {
- "name": "type",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The employee's type.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "string"
- }
- },
- "default": "minion"
- }
- ],
- "name": "foo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo",
- "kind": "function"
- }
- ],
- "namespace": "foo"
- },
- {
- "description": "",
- "tags": [
- {
- "title": "name",
- "description": null,
- "lineNumber": 1,
- "name": "foo"
- },
- {
- "title": "param",
- "description": "some options",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "name": "options"
- },
- {
- "title": "param",
- "description": "how much",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "options.much"
- },
- {
- "title": "param",
- "description": "something else",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "bar"
- },
- {
- "title": "property",
- "description": "the current time",
- "lineNumber": 5,
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "name": "theTime"
- },
- {
- "title": "property",
- "description": null,
- "lineNumber": 6,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "theTime.hours"
- },
- {
- "title": "property",
- "description": null,
- "lineNumber": 7,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "theTime.minutes"
- },
- {
- "title": "property",
- "description": null,
- "lineNumber": 8,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "theTime.seconds"
- },
- {
- "title": "returns",
- "description": "foo something else",
- "lineNumber": 9,
- "type": {
- "type": "NameExpression",
- "name": "Object"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 20,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "foo",
- "params": [
- {
- "name": "options",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "some options",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "properties": [
- {
- "name": "options.much",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "how much",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- },
- {
- "name": "bar",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "something else",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "properties": [
- {
- "name": "theTime",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the current time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "properties": [
- {
- "name": "theTime.hours",
- "lineNumber": 6,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "name": "theTime.minutes",
- "lineNumber": 7,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "name": "theTime.seconds",
- "lineNumber": 8,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "foo something else",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Object"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo"
- }
- ],
- "namespace": "foo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/nest_params.output.md b/test/fixture/nest_params.output.md
deleted file mode 100644
index e0e27edc6..000000000
--- a/test/fixture/nest_params.output.md
+++ /dev/null
@@ -1,27 +0,0 @@
-
-
-# foo
-
-**Parameters**
-
-- `employees` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)>** The employees who are responsible for the project.
- - `employees[].name` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** The name of an employee.
- - `employees[].department` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** The employee's department.
-- `type` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The employee's type. (optional, default `minion`)
-
-# foo
-
-**Parameters**
-
-- `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** some options
- - `options.much` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** how much
-- `bar` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** something else
-
-**Properties**
-
-- `theTime` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** the current time
- - `theTime.hours` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
- - `theTime.minutes` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
- - `theTime.seconds` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-
-Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** foo something else
diff --git a/test/fixture/nest_params.output.md.json b/test/fixture/nest_params.output.md.json
deleted file mode 100644
index 43901c6ce..000000000
--- a/test/fixture/nest_params.output.md.json
+++ /dev/null
@@ -1,894 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "employees"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The employees who are responsible for the project.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 51,
- "offset": 50
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 51,
- "offset": 50
- },
- "indent": []
- }
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "employees[].name"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The name of an employee.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "employees[].department"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The employee's department.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "type"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The employee's type.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "minion"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "some options",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.much"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "how much",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 9,
- "offset": 8
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "bar"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "something else",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "theTime"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the current time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "theTime.hours"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "theTime.minutes"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "theTime.seconds"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "foo something else",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/newline-in-description.output.json b/test/fixture/newline-in-description.output.json
deleted file mode 100644
index 72872085c..000000000
--- a/test/fixture/newline-in-description.output.json
+++ /dev/null
@@ -1,171 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A function.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "The input to the function.\nI should be able to continue the description on a new line, and have it\nstill work in the markdown table.",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- },
- "name": "a"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 0
- }
- }
- },
- "errors": [
- {
- "message": "could not determine @name for hierarchy"
- }
- ],
- "params": [
- {
- "name": "a",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The input to the function.\nI should be able to continue the description on a new line, and have it\nstill work in the markdown table.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 34,
- "offset": 132
- },
- "indent": [
- 1,
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 34,
- "offset": 132
- },
- "indent": [
- 1,
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 34,
- "offset": 132
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {}
- ],
- "namespace": "undefined"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/newline-in-description.output.md b/test/fixture/newline-in-description.output.md
deleted file mode 100644
index 21fab0d89..000000000
--- a/test/fixture/newline-in-description.output.md
+++ /dev/null
@@ -1,11 +0,0 @@
-
-
-#
-
-A function.
-
-**Parameters**
-
-- `a` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** The input to the function.
- I should be able to continue the description on a new line, and have it
- still work in the markdown table.
diff --git a/test/fixture/newline-in-description.output.md.json b/test/fixture/newline-in-description.output.md.json
deleted file mode 100644
index 4489a6504..000000000
--- a/test/fixture/newline-in-description.output.md.json
+++ /dev/null
@@ -1,148 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": ""
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A function.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The input to the function.\nI should be able to continue the description on a new line, and have it\nstill work in the markdown table.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 34,
- "offset": 132
- },
- "indent": [
- 1,
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 34,
- "offset": 132
- },
- "indent": [
- 1,
- 1
- ]
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/no-name.output.json b/test/fixture/no-name.output.json
deleted file mode 100644
index 88452f663..000000000
--- a/test/fixture/no-name.output.json
+++ /dev/null
@@ -1,113 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Set the time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": null,
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "bar"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 0
- }
- }
- },
- "errors": [
- {
- "message": "could not determine @name for hierarchy"
- }
- ],
- "params": [
- {
- "name": "bar",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {}
- ],
- "namespace": "undefined"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/no-name.output.md b/test/fixture/no-name.output.md
deleted file mode 100644
index b210b1461..000000000
--- a/test/fixture/no-name.output.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-#
-
-Set the time
-
-**Parameters**
-
-- `bar` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
diff --git a/test/fixture/no-name.output.md.json b/test/fixture/no-name.output.md.json
deleted file mode 100644
index 7bd427cde..000000000
--- a/test/fixture/no-name.output.md.json
+++ /dev/null
@@ -1,107 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": ""
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Set the time",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "bar"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/optional-record-field-type.output.json b/test/fixture/optional-record-field-type.output.json
deleted file mode 100644
index 7f75271c2..000000000
--- a/test/fixture/optional-record-field-type.output.json
+++ /dev/null
@@ -1,89 +0,0 @@
-[
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 1,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 2,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 2
- }
- }
- },
- "errors": [],
- "name": "Record",
- "kind": "typedef",
- "properties": [
- {
- "title": "property",
- "name": "opt",
- "lineNumber": 3,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- },
- {
- "title": "property",
- "name": "req",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ],
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "opt",
- "value": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- },
- {
- "type": "FieldType",
- "key": "req",
- "value": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ]
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Record",
- "kind": "typedef"
- }
- ],
- "namespace": "Record"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/optional-record-field-type.output.md b/test/fixture/optional-record-field-type.output.md
deleted file mode 100644
index 8cfccccb5..000000000
--- a/test/fixture/optional-record-field-type.output.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-# Record
-
-**Properties**
-
-- `opt` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?**
-- `req` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**
diff --git a/test/fixture/optional-record-field-type.output.md.json b/test/fixture/optional-record-field-type.output.md.json
deleted file mode 100644
index 20a89a866..000000000
--- a/test/fixture/optional-record-field-type.output.md.json
+++ /dev/null
@@ -1,114 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Record"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "opt"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "req"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/params.output.json b/test/fixture/params.output.json
deleted file mode 100644
index 8bf7d42f1..000000000
--- a/test/fixture/params.output.json
+++ /dev/null
@@ -1,2148 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "the second param",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "b"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "b",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the second param",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "title": "param",
- "name": "a",
- "lineNumber": 5
- },
- {
- "title": "param",
- "name": "c",
- "lineNumber": 5
- },
- {
- "title": "param",
- "name": "$3",
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "properties": [
- {
- "title": "param",
- "name": "$3.d",
- "lineNumber": 5
- },
- {
- "title": "param",
- "name": "$3.e",
- "lineNumber": 5
- },
- {
- "title": "param",
- "name": "$3.f",
- "lineNumber": 5
- }
- ]
- }
- ],
- "name": "addThem",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "addThem",
- "kind": "function"
- }
- ],
- "namespace": "addThem"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method has partially inferred params",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "number of kinds of fish",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "String"
- },
- "name": "$0.fishes"
- }
- ],
- "loc": {
- "start": {
- "line": 9,
- "column": 0
- },
- "end": {
- "line": 12,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 0
- },
- "end": {
- "line": 15,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "title": "param",
- "name": "$0",
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "properties": [
- {
- "name": "$0.fishes",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "number of kinds of fish",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "String"
- }
- },
- {
- "title": "param",
- "name": "$0.foxes",
- "lineNumber": 13
- }
- ]
- }
- ],
- "name": "fishesAndFoxes",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "fishesAndFoxes",
- "kind": "function"
- }
- ],
- "namespace": "fishesAndFoxes"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method has a type in the description and a default in the code",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 68,
- "offset": 67
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 68,
- "offset": 67
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 68,
- "offset": 67
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": null,
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "x"
- }
- ],
- "loc": {
- "start": {
- "line": 17,
- "column": 0
- },
- "end": {
- "line": 20,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 21,
- "column": 0
- },
- "end": {
- "line": 23,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "x",
- "lineNumber": 2,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- },
- "default": "2"
- }
- }
- ],
- "name": "withDefault",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "withDefault",
- "kind": "function"
- }
- ],
- "namespace": "withDefault"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is foo's documentation",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 25,
- "column": 0
- },
- "end": {
- "line": 27,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 28,
- "column": 0
- },
- "end": {
- "line": 35,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "Foo",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The method",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "Param to method",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "x"
- }
- ],
- "loc": {
- "start": {
- "line": 29,
- "column": 2
- },
- "end": {
- "line": 32,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 33,
- "column": 2
- },
- "end": {
- "line": 34,
- "column": 3
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "x",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Param to method",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "method",
- "kind": "function",
- "memberof": "Foo",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Foo",
- "kind": "class"
- },
- {
- "name": "method",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "Foo#method"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "Foo",
- "kind": "class"
- }
- ],
- "namespace": "Foo"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Represents an IPv6 address",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of optional parameters",
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 28
- },
- "end": {
- "line": 3,
- "column": 47,
- "offset": 74
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 28
- },
- "end": {
- "line": 3,
- "column": 47,
- "offset": 74
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 47,
- "offset": 74
- }
- }
- },
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 4,
- "type": null,
- "name": "Address6"
- },
- {
- "title": "param",
- "description": "An IPv6 address string",
- "lineNumber": 5,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "address"
- },
- {
- "title": "param",
- "description": "How many octets to parse",
- "lineNumber": 6,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- "name": "groups",
- "default": "8"
- },
- {
- "title": "param",
- "description": "A third argument",
- "lineNumber": 7,
- "type": {
- "type": "NullableType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- },
- "prefix": true
- },
- "name": "third"
- },
- {
- "title": "param",
- "description": "to properly be parsed",
- "lineNumber": 8,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- }
- },
- "name": "foo",
- "default": "[1]"
- },
- {
- "title": "example",
- "description": "var address = new Address6('2001::/32');",
- "lineNumber": 9
- }
- ],
- "loc": {
- "start": {
- "line": 37,
- "column": 0
- },
- "end": {
- "line": 48,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 49,
- "column": 0
- },
- "end": {
- "line": 49,
- "column": 22
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "Address6",
- "params": [
- {
- "name": "address",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "An IPv6 address string",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- },
- {
- "name": "groups",
- "lineNumber": 6,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "How many octets to parse",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- "default": "8"
- },
- {
- "name": "third",
- "lineNumber": 7,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A third argument",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "NullableType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- },
- "prefix": true
- }
- },
- {
- "name": "foo",
- "lineNumber": 8,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "to properly be parsed",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 22,
- "offset": 21
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 22,
- "offset": 21
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 22,
- "offset": 21
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- }
- },
- "default": "[1]"
- }
- ],
- "examples": [
- {
- "description": "var address = new Address6('2001::/32');"
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Address6",
- "kind": "class"
- }
- ],
- "namespace": "Address6"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Create a GeoJSON data source instance given an options object",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 62,
- "offset": 61
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 62,
- "offset": 61
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of nested parameters",
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 63
- },
- "end": {
- "line": 3,
- "column": 44,
- "offset": 106
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 63
- },
- "end": {
- "line": 3,
- "column": 44,
- "offset": 106
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 3,
- "column": 44,
- "offset": 106
- }
- }
- },
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 4,
- "type": null,
- "name": "GeoJSONSource"
- },
- {
- "title": "param",
- "description": "optional options",
- "lineNumber": 5,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- "name": "options"
- },
- {
- "title": "param",
- "description": "A GeoJSON data object or URL to it.\nThe latter is preferable in case of large GeoJSON files.",
- "lineNumber": 6,
- "type": {
- "type": "UnionType",
- "elements": [
- {
- "type": "NameExpression",
- "name": "Object"
- },
- {
- "type": "NameExpression",
- "name": "string"
- }
- ]
- },
- "name": "options.data"
- },
- {
- "title": "param",
- "description": "Maximum zoom to preserve detail at.",
- "lineNumber": 8,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- "name": "options.maxzoom",
- "default": "14"
- },
- {
- "title": "param",
- "description": "Tile buffer on each side.",
- "lineNumber": 9,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- "name": "options.buffer"
- },
- {
- "title": "param",
- "description": "Simplification tolerance (higher means simpler).",
- "lineNumber": 10,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- "name": "options.tolerance"
- }
- ],
- "loc": {
- "start": {
- "line": 51,
- "column": 0
- },
- "end": {
- "line": 62,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 63,
- "column": 0
- },
- "end": {
- "line": 65,
- "column": 1
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "GeoJSONSource",
- "params": [
- {
- "name": "options",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "optional options",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- "properties": [
- {
- "name": "options.data",
- "lineNumber": 6,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A GeoJSON data object or URL to it.\nThe latter is preferable in case of large GeoJSON files.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 92
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 92
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 92
- }
- }
- },
- "type": {
- "type": "UnionType",
- "elements": [
- {
- "type": "NameExpression",
- "name": "Object"
- },
- {
- "type": "NameExpression",
- "name": "string"
- }
- ]
- }
- },
- {
- "name": "options.maxzoom",
- "lineNumber": 8,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Maximum zoom to preserve detail at.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- "default": "14"
- },
- {
- "name": "options.buffer",
- "lineNumber": 9,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Tile buffer on each side.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- },
- {
- "name": "options.tolerance",
- "lineNumber": 10,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Simplification tolerance (higher means simpler).",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 49,
- "offset": 48
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 49,
- "offset": 48
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 49,
- "offset": 48
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- }
- ]
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "GeoJSONSource",
- "kind": "class"
- }
- ],
- "namespace": "GeoJSONSource"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support for parameters with explicit types but with default\nvalues specified in code.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 100
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 100
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 100
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "an argument",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "x"
- },
- {
- "title": "returns",
- "description": "some",
- "lineNumber": 6,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 67,
- "column": 0
- },
- "end": {
- "line": 74,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 75,
- "column": 0
- },
- "end": {
- "line": 75,
- "column": 37
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "x",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "an argument",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- },
- "default": "123"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "some",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 5,
- "offset": 4
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 5,
- "offset": 4
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 5,
- "offset": 4
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "myfunc",
- "kind": "constant",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "myfunc",
- "kind": "constant"
- }
- ],
- "namespace": "myfunc"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of JSDoc param tags without type information,\nor any type information we could infer from annotations.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 125
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 125
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 125
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "An IPv6 address string",
- "lineNumber": 4,
- "type": null,
- "name": "address"
- }
- ],
- "loc": {
- "start": {
- "line": 77,
- "column": 0
- },
- "end": {
- "line": 82,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 83,
- "column": 0
- },
- "end": {
- "line": 85,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "address",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "An IPv6 address string",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- }
- }
- ],
- "name": "foo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo",
- "kind": "function"
- }
- ],
- "namespace": "foo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/params.output.md b/test/fixture/params.output.md
deleted file mode 100644
index 384ca453c..000000000
--- a/test/fixture/params.output.md
+++ /dev/null
@@ -1,99 +0,0 @@
-
-
-# addThem
-
-This function returns the number one.
-
-**Parameters**
-
-- `b` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** the second param
-- `a`
-- `c`
-- `$3` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)**
- - `$3.d`
- - `$3.e`
- - `$3.f`
-
-# fishesAndFoxes
-
-This method has partially inferred params
-
-**Parameters**
-
-- `$0` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)**
- - `$0.fishes` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** number of kinds of fish
- - `$0.foxes`
-
-# withDefault
-
-This method has a type in the description and a default in the code
-
-**Parameters**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?= 2**
-
-# Foo
-
-This is foo's documentation
-
-## method
-
-The method
-
-**Parameters**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Param to method
-
-# Address6
-
-Represents an IPv6 address
-
-This tests our support of optional parameters
-
-**Parameters**
-
-- `address` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** An IPv6 address string
-- `groups` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** How many octets to parse (optional, default `8`)
-- `third` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** A third argument
-- `foo` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** to properly be parsed (optional, default `[1]`)
-
-**Examples**
-
-```javascript
-var address = new Address6('2001::/32');
-```
-
-# GeoJSONSource
-
-Create a GeoJSON data source instance given an options object
-
-This tests our support of nested parameters
-
-**Parameters**
-
-- `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)?** optional options
- - `options.data` **([Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String))** A GeoJSON data object or URL to it.
- The latter is preferable in case of large GeoJSON files.
- - `options.maxzoom` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Maximum zoom to preserve detail at. (optional, default `14`)
- - `options.buffer` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Tile buffer on each side.
- - `options.tolerance` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Simplification tolerance (higher means simpler).
-
-# myfunc
-
-This tests our support for parameters with explicit types but with default
-values specified in code.
-
-**Parameters**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?= 123** an argument
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** some
-
-# foo
-
-This tests our support of JSDoc param tags without type information,
-or any type information we could infer from annotations.
-
-**Parameters**
-
-- `address` An IPv6 address string
diff --git a/test/fixture/params.output.md.json b/test/fixture/params.output.md.json
deleted file mode 100644
index be4bc42a4..000000000
--- a/test/fixture/params.output.md.json
+++ /dev/null
@@ -1,2082 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "addThem"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "b"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the second param",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "c"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$3"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$3.d"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$3.e"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$3.f"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "fishesAndFoxes"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method has partially inferred params",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 42,
- "offset": 41
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.fishes"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "String"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "number of kinds of fish",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 24,
- "offset": 23
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "$0.foxes"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "withDefault"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This method has a type in the description and a default in the code",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 68,
- "offset": 67
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 68,
- "offset": 67
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- },
- {
- "type": "text",
- "value": "= 2"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is foo's documentation",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "method"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The method",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Param to method",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Address6"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Represents an IPv6 address",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of optional parameters",
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 28
- },
- "end": {
- "line": 3,
- "column": 47,
- "offset": 74
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 28
- },
- "end": {
- "line": 3,
- "column": 47,
- "offset": 74
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "address"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "An IPv6 address string",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "groups"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "How many octets to parse",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "8"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "third"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A third argument",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "foo"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "to properly be parsed",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 22,
- "offset": 21
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 22,
- "offset": 21
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "[1]"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Examples"
- }
- ]
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "var address = new Address6('2001::/32');"
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "GeoJSONSource"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Create a GeoJSON data source instance given an options object",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 62,
- "offset": 61
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 62,
- "offset": 61
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of nested parameters",
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 63
- },
- "end": {
- "line": 3,
- "column": 44,
- "offset": 106
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 3,
- "column": 1,
- "offset": 63
- },
- "end": {
- "line": 3,
- "column": 44,
- "offset": 106
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "optional options",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.data"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "("
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": " | "
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A GeoJSON data object or URL to it.\nThe latter is preferable in case of large GeoJSON files.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 92
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 92
- },
- "indent": [
- 1
- ]
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.maxzoom"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Maximum zoom to preserve detail at.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "14"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.buffer"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Tile buffer on each side.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 26,
- "offset": 25
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.tolerance"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Simplification tolerance (higher means simpler).",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 49,
- "offset": 48
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 49,
- "offset": 48
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "myfunc"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support for parameters with explicit types but with default\nvalues specified in code.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 100
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 26,
- "offset": 100
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- },
- {
- "type": "text",
- "value": "= 123"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "an argument",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "some",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 5,
- "offset": 4
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 5,
- "offset": 4
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This tests our support of JSDoc param tags without type information,\nor any type information we could infer from annotations.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 125
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 57,
- "offset": 125
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "address"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "An IPv6 address string",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/polyglot/blend.cpp b/test/fixture/polyglot/blend.cpp
deleted file mode 100644
index a285feb9c..000000000
--- a/test/fixture/polyglot/blend.cpp
+++ /dev/null
@@ -1,675 +0,0 @@
-#include
-#include
-#include
-
-#include "zlib.h"
-
-#if defined(HAVE_PNG)
-#include
-#endif
-
-#if defined(HAVE_JPEG)
-#define XMD_H
-#include
-#undef XMD_H
-#endif
-
-#if defined(HAVE_WEBP)
-#include
-#endif
-
-#include "mapnik_palette.hpp"
-#include "blend.hpp"
-#include "tint.hpp"
-
-#include
-#include
-#include
-#include
-
-using namespace v8;
-using namespace node;
-
-namespace node_mapnik {
-
-/**
- * This method moves a hex to a color
- * @name hexToUInt32Color
- * @param {string} hex
- * @returns {number} color
- */
-static bool hexToUInt32Color(char *hex, unsigned int & value) {
- if (!hex) return false;
- int len_original = strlen(hex);
- // Return is the length of the string is less then six
- // otherwise the line after this could go to some other
- // pointer in memory, resulting in strange behaviours.
- if (len_original < 6) return false;
- if (hex[0] == '#') hex++;
- int len = strlen(hex);
- if (len != 6 && len != 8) return false;
-
- unsigned int color = 0;
- std::stringstream ss;
- ss << std::hex << hex;
- ss >> color;
-
- if (len == 8) {
- // Circular shift to get from RGBA to ARGB.
- value = (color << 24) | ((color & 0xFF00) << 8) | ((color & 0xFF0000) >> 8) | ((color & 0xFF000000) >> 24);
- return true;
- } else {
- value = 0xFF000000 | ((color & 0xFF) << 16) | (color & 0xFF00) | ((color & 0xFF0000) >> 16);
- return true;
- }
-}
-
-NAN_METHOD(rgb2hsl) {
- NanScope();
- if (args.Length() != 3) {
- NanThrowTypeError("Please pass r,g,b integer values as three arguments");
- NanReturnUndefined();
- }
- if (!args[0]->IsNumber() || !args[1]->IsNumber() || !args[2]->IsNumber()) {
- NanThrowTypeError("Please pass r,g,b integer values as three arguments");
- NanReturnUndefined();
- }
- unsigned r,g,b;
- r = args[0]->IntegerValue();
- g = args[1]->IntegerValue();
- b = args[2]->IntegerValue();
- Local hsl = NanNew(3);
- double h,s,l;
- rgb_to_hsl(r,g,b,h,s,l);
- hsl->Set(0,NanNew(h));
- hsl->Set(1,NanNew(s));
- hsl->Set(2,NanNew(l));
- NanReturnValue(hsl);
-}
-
-NAN_METHOD(hsl2rgb) {
- NanScope();
- if (args.Length() != 3) {
- NanThrowTypeError("Please pass hsl fractional values as three arguments");
- NanReturnUndefined();
- }
- if (!args[0]->IsNumber() || !args[1]->IsNumber() || !args[2]->IsNumber()) {
- NanThrowTypeError("Please pass hsl fractional values as three arguments");
- NanReturnUndefined();
- }
- double h,s,l;
- h = args[0]->NumberValue();
- s = args[1]->NumberValue();
- l = args[2]->NumberValue();
- Local rgb = NanNew(3);
- unsigned r,g,b;
- hsl_to_rgb(h,s,l,r,g,b);
- rgb->Set(0,NanNew(r));
- rgb->Set(1,NanNew(g));
- rgb->Set(2,NanNew(b));
- NanReturnValue(rgb);
-}
-
-static void parseTintOps(Local const& tint, Tinter & tinter, std::string & msg) {
- NanScope();
- Local hue = tint->Get(NanNew("h"));
- if (!hue.IsEmpty() && hue->IsArray()) {
- Local val_array = Local::Cast(hue);
- if (val_array->Length() != 2) {
- msg = "h array must be a pair of values";
- }
- tinter.h0 = val_array->Get(0)->NumberValue();
- tinter.h1 = val_array->Get(1)->NumberValue();
- }
- Local sat = tint->Get(NanNew("s"));
- if (!sat.IsEmpty() && sat->IsArray()) {
- Local val_array = Local::Cast(sat);
- if (val_array->Length() != 2) {
- msg = "s array must be a pair of values";
- }
- tinter.s0 = val_array->Get(0)->NumberValue();
- tinter.s1 = val_array->Get(1)->NumberValue();
- }
- Local light = tint->Get(NanNew("l"));
- if (!light.IsEmpty() && light->IsArray()) {
- Local val_array = Local::Cast(light);
- if (val_array->Length() != 2) {
- msg = "l array must be a pair of values";
- }
- tinter.l0 = val_array->Get(0)->NumberValue();
- tinter.l1 = val_array->Get(1)->NumberValue();
- }
- Local alpha = tint->Get(NanNew("a"));
- if (!alpha.IsEmpty() && alpha->IsArray()) {
- Local val_array = Local::Cast(alpha);
- if (val_array->Length() != 2) {
- msg = "a array must be a pair of values";
- }
- tinter.a0 = val_array->Get(0)->NumberValue();
- tinter.a1 = val_array->Get(1)->NumberValue();
- }
-}
-
-static inline void Blend_CompositePixel(unsigned int& target, unsigned int const& source) {
- if (source <= 0x00FFFFFF) {
- // Top pixel is fully transparent.
- //
- } else if (source >= 0xFF000000 || target <= 0x00FFFFFF) {
- // Top pixel is fully opaque or bottom pixel is fully transparent.
- target = source;
- } else {
- // Both pixels have transparency.
- // From http://trac.mapnik.org/browser/trunk/include/mapnik/graphics.hpp#L337
- long a1 = (source >> 24) & 0xff;
- long r1 = source & 0xff;
- long g1 = (source >> 8) & 0xff;
- long b1 = (source >> 16) & 0xff;
-
- long a0 = (target >> 24) & 0xff;
- long r0 = (target & 0xff) * a0;
- long g0 = ((target >> 8) & 0xff) * a0;
- long b0 = ((target >> 16) & 0xff) * a0;
-
- a0 = ((a1 + a0) << 8) - a0 * a1;
- r0 = ((((r1 << 8) - r0) * a1 + (r0 << 8)) / a0);
- g0 = ((((g1 << 8) - g0) * a1 + (g0 << 8)) / a0);
- b0 = ((((b1 << 8) - b0) * a1 + (b0 << 8)) / a0);
- a0 = a0 >> 8;
- target = (a0 << 24) | (b0 << 16) | (g0 << 8) | (r0);
- }
-}
-
-static inline void TintPixel(unsigned & r,
- unsigned & g,
- unsigned & b,
- Tinter const& tint) {
- double h;
- double s;
- double l;
- rgb_to_hsl(r,g,b,h,s,l);
- double h2 = tint.h0 + (h * (tint.h1 - tint.h0));
- double s2 = tint.s0 + (s * (tint.s1 - tint.s0));
- double l2 = tint.l0 + (l * (tint.l1 - tint.l0));
- if (h2 > 1) h2 = 1;
- if (h2 < 0) h2 = 0;
- if (s2 > 1) s2 = 1;
- if (s2 < 0) s2 = 0;
- if (l2 > 1) l2 = 1;
- if (l2 < 0) l2 = 0;
- hsl_to_rgb(h2,s2,l2,r,g,b);
-}
-
-
-static void Blend_Composite(unsigned int *target, BlendBaton *baton, BImage *image) {
- const unsigned int *source = image->im_ptr->data();
-
- int sourceX = std::max(0, -image->x);
- int sourceY = std::max(0, -image->y);
- int sourcePos = sourceY * image->width + sourceX;
-
- int width = image->width - sourceX - std::max(0, image->x + image->width - baton->width);
- int height = image->height - sourceY - std::max(0, image->y + image->height - baton->height);
-
- int targetX = std::max(0, image->x);
- int targetY = std::max(0, image->y);
- int targetPos = targetY * baton->width + targetX;
- bool tinting = !image->tint.is_identity();
- bool set_alpha = !image->tint.is_alpha_identity();
- if (tinting || set_alpha) {
- for (int y = 0; y < height; y++) {
- for (int x = 0; x < width; x++) {
- unsigned int const& source_pixel = source[sourcePos + x];
- unsigned a = (source_pixel >> 24) & 0xff;
- if (set_alpha) {
- double a2 = image->tint.a0 + (a/255.0 * (image->tint.a1 - image->tint.a0));
- if (a2 < 0) a2 = 0;
- a = static_cast(std::floor((a2 * 255.0)+.5));
- if (a > 255) a = 255;
- }
- unsigned r = source_pixel & 0xff;
- unsigned g = (source_pixel >> 8 ) & 0xff;
- unsigned b = (source_pixel >> 16) & 0xff;
- if (a > 1 && tinting) {
- TintPixel(r,g,b,image->tint);
- }
- unsigned int new_pixel = (a << 24) | (b << 16) | (g << 8) | (r);
- Blend_CompositePixel(target[targetPos + x], new_pixel);
- }
- sourcePos += image->width;
- targetPos += baton->width;
- }
- } else {
- for (int y = 0; y < height; y++) {
- for (int x = 0; x < width; x++) {
- Blend_CompositePixel(target[targetPos + x], source[sourcePos + x]);
- }
- sourcePos += image->width;
- targetPos += baton->width;
- }
- }
-}
-
-static void Blend_Encode(mapnik::image_rgba8 const& image, BlendBaton* baton, bool alpha) {
- try {
- if (baton->format == BLEND_FORMAT_JPEG) {
-#if defined(HAVE_JPEG)
- if (baton->quality == 0) baton->quality = 85;
- mapnik::save_as_jpeg(baton->stream, baton->quality, image);
-#else
- baton->message = "Mapnik not built with jpeg support";
-#endif
- } else if (baton->format == BLEND_FORMAT_WEBP) {
-#if defined(HAVE_WEBP)
- if (baton->quality == 0) baton->quality = 80;
- WebPConfig config;
- // Default values set here will be lossless=0 and quality=75 (as least as of webp v0.3.1)
- if (!WebPConfigInit(&config)) {
- /* LCOV_EXCL_START */
- baton->message = "WebPConfigInit failed: version mismatch";
- /* LCOV_EXCL_END */
- } else {
- // see for more details: https://github.com/mapnik/mapnik/wiki/Image-IO#webp-output-options
- config.quality = baton->quality;
- if (baton->compression > 0) {
- config.method = baton->compression;
- }
- mapnik::save_as_webp(baton->stream,image,config,alpha);
- }
-#else
- baton->message = "Mapnik not built with webp support";
-#endif
- } else {
- // Save as PNG.
-#if defined(HAVE_PNG)
- mapnik::png_options opts;
- opts.compression = baton->compression;
- if (baton->encoder == BLEND_ENCODER_MINIZ) opts.use_miniz = true;
- if (baton->palette && baton->palette->valid()) {
- mapnik::save_as_png8_pal(baton->stream, image, *baton->palette, opts);
- } else if (baton->quality > 0) {
- opts.colors = baton->quality;
- // Paletted PNG.
- if (alpha && baton->mode == BLEND_MODE_HEXTREE) {
- mapnik::save_as_png8_hex(baton->stream, image, opts);
- } else {
- mapnik::save_as_png8_oct(baton->stream, image, opts);
- }
- } else {
- mapnik::save_as_png(baton->stream, image, opts);
- }
-#else
- baton->message = "Mapnik not built with png support";
-#endif
- }
- } catch (const std::exception& ex) {
- baton->message = ex.what();
- }
-}
-
-void Work_Blend(uv_work_t* req) {
- BlendBaton* baton = static_cast(req->data);
-
- int total = baton->images.size();
- bool alpha = true;
- int size = 0;
-
- // Iterate from the last to first image because we potentially don't have
- // to decode all images if there's an opaque one.
- Images::reverse_iterator rit = baton->images.rbegin();
- Images::reverse_iterator rend = baton->images.rend();
- for (int index = total - 1; rit != rend; rit++, index--) {
- // If an image that is higher than the current is opaque, stop alltogether.
- if (!alpha) break;
-
- BImage *image = &**rit;
- std::unique_ptr image_reader;
- try {
- image_reader = std::unique_ptr(mapnik::get_image_reader(image->data, image->dataLength));
- } catch (std::exception const& ex) {
- baton->message = ex.what();
- return;
- }
-
- if (!image_reader || !image_reader.get()) {
- // Not quite sure anymore how the pointer would not be returned
- // from the reader and can't find a way to make this fail.
- // So removing from coverage
- /* LCOV_EXCL_START */
- baton->message = "Unknown image format";
- return;
- /* LCOV_EXCL_END */
- }
-
- unsigned layer_width = image_reader->width();
- unsigned layer_height = image_reader->height();
- // Error out on invalid images.
- if (layer_width == 0 || layer_height == 0) {
- // No idea how to create a zero height or width image
- // so removing from coverage, because I am fairly certain
- // it is not possible in almost every image format.
- /* LCOV_EXCL_START */
- baton->message = "zero width/height image encountered";
- return;
- /* LCOV_EXCL_END */
- }
-
- int visibleWidth = (int)layer_width + image->x;
- int visibleHeight = (int)layer_height + image->y;
- // The first image that is in the viewport sets the width/height, if not user supplied.
- if (baton->width <= 0) baton->width = std::max(0, visibleWidth);
- if (baton->height <= 0) baton->height = std::max(0, visibleHeight);
-
- // Skip images that are outside of the viewport.
- if (visibleWidth <= 0 || visibleHeight <= 0 || image->x >= baton->width || image->y >= baton->height) {
- // Remove this layer from the list of layers we consider blending.
- continue;
- }
-
- bool layer_has_alpha = image_reader->has_alpha();
-
- // Short-circuit when we're not reencoding.
- if (size == 0 && !layer_has_alpha && !baton->reencode &&
- image->x == 0 && image->y == 0 &&
- (int)layer_width == baton->width && (int)layer_height == baton->height)
- {
- baton->stream.write((char *)image->data, image->dataLength);
- return;
- }
-
- // allocate image for decoded pixels
- std::unique_ptr im_ptr(new mapnik::image_rgba8(layer_width,layer_height));
- // actually decode pixels now
- try {
- image_reader->read(0,0,*im_ptr);
- } catch (std::exception const&) {
- baton->message = "Could not decode image";
- return;
- }
-
- bool coversWidth = image->x <= 0 && visibleWidth >= baton->width;
- bool coversHeight = image->y <= 0 && visibleHeight >= baton->height;
- if (!layer_has_alpha && coversWidth && coversHeight && image->tint.is_alpha_identity()) {
- // Skip decoding more layers.
- alpha = false;
- }
-
- // Convenience aliases.
- image->width = layer_width;
- image->height = layer_height;
- image->im_ptr = std::move(im_ptr);
- size++;
-
- }
-
- // Now blend images.
- int pixels = baton->width * baton->height;
- if (pixels <= 0) {
- std::ostringstream msg;
- msg << "Image dimensions " << baton->width << "x" << baton->height << " are invalid";
- baton->message = msg.str();
- return;
- }
-
- mapnik::image_rgba8 target(baton->width, baton->height);
- // When we don't actually have transparent pixels, we don't need to set the matte.
- if (alpha) {
- target.set(baton->matte);
- }
- for (auto image_ptr : baton->images)
- {
- if (image_ptr && image_ptr->im_ptr.get())
- {
- Blend_Composite(target.data(), baton, &*image_ptr);
- }
- }
- Blend_Encode(target, baton, alpha);
-}
-
-void Work_AfterBlend(uv_work_t* req) {
- NanScope();
- BlendBaton* baton = static_cast(req->data);
-
- if (!baton->message.length()) {
- std::string result = baton->stream.str();
- Local argv[] = {
- NanNull(),
- NanNewBufferHandle((char *)result.data(), result.length()),
- };
- NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(baton->callback), 2, argv);
- } else {
- Local argv[] = {
- NanError(baton->message.c_str())
- };
- NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(baton->callback), 1, argv);
- }
- delete baton;
-}
-
-NAN_METHOD(Blend) {
- NanScope();
- std::unique_ptr baton(new BlendBaton());
-
- Local options;
- if (args.Length() == 0 || !args[0]->IsArray()) {
- NanThrowTypeError("First argument must be an array of Buffers.");
- NanReturnUndefined();
- } else if (args.Length() == 1) {
- NanThrowTypeError("Second argument must be a function");
- NanReturnUndefined();
- } else if (args.Length() == 2) {
- // No options provided.
- if (!args[1]->IsFunction()) {
- NanThrowTypeError("Second argument must be a function.");
- NanReturnUndefined();
- }
- NanAssignPersistent(baton->callback,args[1].As());
- } else if (args.Length() >= 3) {
- if (!args[1]->IsObject()) {
- NanThrowTypeError("Second argument must be a an options object.");
- NanReturnUndefined();
- }
- options = Local::Cast(args[1]);
-
- if (!args[2]->IsFunction()) {
- NanThrowTypeError("Third argument must be a function.");
- NanReturnUndefined();
- }
- NanAssignPersistent(baton->callback,args[2].As());
- }
-
- // Validate options
- if (!options.IsEmpty()) {
- baton->quality = options->Get(NanNew("quality"))->Int32Value();
-
- Local format_val = options->Get(NanNew("format"));
- if (!format_val.IsEmpty() && format_val->IsString()) {
- if (strcmp(*String::Utf8Value(format_val), "jpeg") == 0 ||
- strcmp(*String::Utf8Value(format_val), "jpg") == 0) {
- baton->format = BLEND_FORMAT_JPEG;
- if (baton->quality == 0) baton->quality = 85; // 85 is same default as mapnik core jpeg
- else if (baton->quality < 0 || baton->quality > 100) {
- NanThrowTypeError("JPEG quality is range 0-100.");
- NanReturnUndefined();
- }
- } else if (strcmp(*String::Utf8Value(format_val), "png") == 0) {
- if (baton->quality == 1 || baton->quality > 256) {
- NanThrowTypeError("PNG images must be quantized between 2 and 256 colors.");
- NanReturnUndefined();
- }
- } else if (strcmp(*String::Utf8Value(format_val), "webp") == 0) {
- baton->format = BLEND_FORMAT_WEBP;
- if (baton->quality == 0) baton->quality = 80;
- else if (baton->quality < 0 || baton->quality > 100) {
- NanThrowTypeError("WebP quality is range 0-100.");
- NanReturnUndefined();
- }
- } else {
- NanThrowTypeError("Invalid output format.");
- NanReturnUndefined();
- }
- }
-
- baton->reencode = options->Get(NanNew("reencode"))->BooleanValue();
- baton->width = options->Get(NanNew("width"))->Int32Value();
- baton->height = options->Get(NanNew("height"))->Int32Value();
-
- Local matte_val = options->Get(NanNew("matte"));
- if (!matte_val.IsEmpty() && matte_val->IsString()) {
- if (!hexToUInt32Color(*String::Utf8Value(matte_val->ToString()), baton->matte))
- {
- NanThrowTypeError("Invalid batte provided.");
- NanReturnUndefined();
- }
-
- // Make sure we're reencoding in the case of single alpha PNGs
- if (baton->matte && !baton->reencode) {
- baton->reencode = true;
- }
- }
-
- Local palette_val = options->Get(NanNew("palette"));
- if (!palette_val.IsEmpty() && palette_val->IsObject()) {
- baton->palette = node::ObjectWrap::Unwrap(palette_val->ToObject())->palette();
- }
-
- Local mode_val = options->Get(NanNew("mode"));
- if (!mode_val.IsEmpty() && mode_val->IsString()) {
- if (strcmp(*String::Utf8Value(mode_val), "octree") == 0 ||
- strcmp(*String::Utf8Value(mode_val), "o") == 0) {
- baton->mode = BLEND_MODE_OCTREE;
- }
- else if (strcmp(*String::Utf8Value(mode_val), "hextree") == 0 ||
- strcmp(*String::Utf8Value(mode_val), "h") == 0) {
- baton->mode = BLEND_MODE_HEXTREE;
- }
- }
-
- Local encoder_val = options->Get(NanNew("encoder"));
- if (!encoder_val.IsEmpty() && encoder_val->IsString()) {
- if (strcmp(*String::Utf8Value(encoder_val), "miniz") == 0) {
- baton->encoder = BLEND_ENCODER_MINIZ;
- }
- // default is libpng
- }
-
- if (options->Has(NanNew("compression"))) {
- Local compression_val = options->Get(NanNew("compression"));
- if (!compression_val.IsEmpty() && compression_val->IsNumber())
- {
- baton->compression = compression_val->Int32Value();
- }
- else
- {
- NanThrowTypeError("Compression option must be a number");
- NanReturnUndefined();
- }
- }
-
- int min_compression = Z_NO_COMPRESSION;
- int max_compression = Z_BEST_COMPRESSION;
- if (baton->format == BLEND_FORMAT_PNG) {
- if (baton->compression < 0) baton->compression = Z_DEFAULT_COMPRESSION;
- if (baton->encoder == BLEND_ENCODER_MINIZ) max_compression = 10; // MZ_UBER_COMPRESSION
- } else if (baton->format == BLEND_FORMAT_WEBP) {
- min_compression = 0, max_compression = 6;
- if (baton->compression < 0) baton->compression = -1;
- }
-
- if (baton->compression > max_compression) {
- std::ostringstream msg;
- msg << "Compression level must be between "
- << min_compression << " and " << max_compression;
- NanThrowTypeError(msg.str().c_str());
- NanReturnUndefined();
- }
- }
-
- Local js_images = Local::Cast(args[0]);
- uint32_t length = js_images->Length();
- if (length < 1 && !baton->reencode) {
- NanThrowTypeError("First argument must contain at least one Buffer.");
- NanReturnUndefined();
- } else if (length == 1 && !baton->reencode) {
- Local buffer = js_images->Get(0);
- if (Buffer::HasInstance(buffer)) {
- // Directly pass through buffer if it's the only one.
- Local argv[] = {
- NanNull(),
- buffer
- };
- NanMakeCallback(NanGetCurrentContext()->Global(), NanNew(baton->callback), 2, argv);
- NanReturnUndefined();
- } else {
- // Check whether the argument is a complex image with offsets etc.
- // In that case, we don't throw but continue going through the blend
- // process below.
- bool valid = false;
- if (buffer->IsObject()) {
- Local props = buffer->ToObject();
- valid = props->Has(NanNew("buffer")) &&
- Buffer::HasInstance(props->Get(NanNew("buffer")));
- }
- if (!valid) {
- NanThrowTypeError("All elements must be Buffers or objects with a 'buffer' property.");
- NanReturnUndefined();
- }
- }
- }
-
- if (!(length >= 1 || (baton->width > 0 && baton->height > 0))) {
- NanThrowTypeError("Without buffers, you have to specify width and height.");
- NanReturnUndefined();
- }
-
- if (baton->width < 0 || baton->height < 0) {
- NanThrowTypeError("Image dimensions must be greater than 0.");
- NanReturnUndefined();
- }
-
- for (uint32_t i = 0; i < length; i++) {
- ImagePtr image = std::make_shared();
- Local buffer = js_images->Get(i);
- if (Buffer::HasInstance(buffer)) {
- NanAssignPersistent(image->buffer,buffer.As());
- } else if (buffer->IsObject()) {
- Local props = buffer->ToObject();
- if (props->Has(NanNew("buffer"))) {
- buffer = props->Get(NanNew("buffer"));
- if (Buffer::HasInstance(buffer)) {
- NanAssignPersistent(image->buffer,buffer.As());
- }
- }
- image->x = props->Get(NanNew("x"))->Int32Value();
- image->y = props->Get(NanNew("y"))->Int32Value();
-
- Local tint_val = props->Get(NanNew("tint"));
- if (!tint_val.IsEmpty() && tint_val->IsObject()) {
- Local tint = tint_val->ToObject();
- if (!tint.IsEmpty()) {
- baton->reencode = true;
- std::string msg;
- parseTintOps(tint,image->tint,msg);
- if (!msg.empty()) {
- NanThrowTypeError(msg.c_str());
- NanReturnUndefined();
- }
- }
- }
- }
-
- if (image->buffer.IsEmpty()) {
- NanThrowTypeError("All elements must be Buffers or objects with a 'buffer' property.");
- NanReturnUndefined();
- }
-
- image->data = node::Buffer::Data(buffer);
- image->dataLength = node::Buffer::Length(buffer);
- baton->images.push_back(image);
- }
-
- uv_queue_work(uv_default_loop(), &(baton.release())->request, Work_Blend, (uv_after_work_cb)Work_AfterBlend);
-
- NanReturnUndefined();
-}
-
-}
diff --git a/test/fixture/react-jsx.output.json b/test/fixture/react-jsx.output.json
deleted file mode 100644
index 5a830b1a5..000000000
--- a/test/fixture/react-jsx.output.json
+++ /dev/null
@@ -1,93 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "apples",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 20
- }
- }
- },
- "errors": [],
- "name": "apples",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "apples",
- "kind": "function"
- }
- ],
- "namespace": "apples"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/react-jsx.output.md b/test/fixture/react-jsx.output.md
deleted file mode 100644
index f93d2550d..000000000
--- a/test/fixture/react-jsx.output.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-# apples
-
-apples
diff --git a/test/fixture/react-jsx.output.md.json b/test/fixture/react-jsx.output.md.json
deleted file mode 100644
index 826fc6201..000000000
--- a/test/fixture/react-jsx.output.md.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "apples"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "apples",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 7,
- "offset": 6
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/require-json-no-extension.output.json b/test/fixture/require-json-no-extension.output.json
deleted file mode 100644
index 0637a088a..000000000
--- a/test/fixture/require-json-no-extension.output.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
\ No newline at end of file
diff --git a/test/fixture/require-json-no-extension.output.md b/test/fixture/require-json-no-extension.output.md
deleted file mode 100644
index 1fcb902bc..000000000
--- a/test/fixture/require-json-no-extension.output.md
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test/fixture/require-json-no-extension.output.md.json b/test/fixture/require-json-no-extension.output.md.json
deleted file mode 100644
index c4109240d..000000000
--- a/test/fixture/require-json-no-extension.output.md.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/require-json.json b/test/fixture/require-json.json
deleted file mode 100644
index 0967ef424..000000000
--- a/test/fixture/require-json.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/test/fixture/require-json.output.json b/test/fixture/require-json.output.json
deleted file mode 100644
index 0637a088a..000000000
--- a/test/fixture/require-json.output.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
\ No newline at end of file
diff --git a/test/fixture/require-json.output.md b/test/fixture/require-json.output.md
deleted file mode 100644
index 1fcb902bc..000000000
--- a/test/fixture/require-json.output.md
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test/fixture/require-json.output.md.json b/test/fixture/require-json.output.md.json
deleted file mode 100644
index c4109240d..000000000
--- a/test/fixture/require-json.output.md.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/simple-hashbang.output.json b/test/fixture/simple-hashbang.output.json
deleted file mode 100644
index 59c584956..000000000
--- a/test/fixture/simple-hashbang.output.json
+++ /dev/null
@@ -1,163 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 10,
- "column": 2
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "name": "simple-hashbang.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "simple-hashbang.input",
- "kind": "function"
- }
- ],
- "namespace": "simple-hashbang.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/simple-hashbang.output.md b/test/fixture/simple-hashbang.output.md
deleted file mode 100644
index a13e7f4a3..000000000
--- a/test/fixture/simple-hashbang.output.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-# simple-hashbang.input
-
-This function returns the number one.
-
-Returns **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/simple-hashbang.output.md.json b/test/fixture/simple-hashbang.output.md.json
deleted file mode 100644
index ff6b6f17f..000000000
--- a/test/fixture/simple-hashbang.output.md.json
+++ /dev/null
@@ -1,118 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "simple-hashbang.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/simple-private.output.json b/test/fixture/simple-private.output.json
deleted file mode 100644
index 0637a088a..000000000
--- a/test/fixture/simple-private.output.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
\ No newline at end of file
diff --git a/test/fixture/simple-private.output.md b/test/fixture/simple-private.output.md
deleted file mode 100644
index 1fcb902bc..000000000
--- a/test/fixture/simple-private.output.md
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test/fixture/simple-private.output.md.json b/test/fixture/simple-private.output.md.json
deleted file mode 100644
index c4109240d..000000000
--- a/test/fixture/simple-private.output.md.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/simple-singlestar.output.json b/test/fixture/simple-singlestar.output.json
deleted file mode 100644
index 0637a088a..000000000
--- a/test/fixture/simple-singlestar.output.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
\ No newline at end of file
diff --git a/test/fixture/simple-singlestar.output.md b/test/fixture/simple-singlestar.output.md
deleted file mode 100644
index 1fcb902bc..000000000
--- a/test/fixture/simple-singlestar.output.md
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test/fixture/simple-singlestar.output.md.json b/test/fixture/simple-singlestar.output.md.json
deleted file mode 100644
index c4109240d..000000000
--- a/test/fixture/simple-singlestar.output.md.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/simple-triplestar.output.json b/test/fixture/simple-triplestar.output.json
deleted file mode 100644
index 0637a088a..000000000
--- a/test/fixture/simple-triplestar.output.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
\ No newline at end of file
diff --git a/test/fixture/simple-triplestar.output.md b/test/fixture/simple-triplestar.output.md
deleted file mode 100644
index 1fcb902bc..000000000
--- a/test/fixture/simple-triplestar.output.md
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/test/fixture/simple-triplestar.output.md.json b/test/fixture/simple-triplestar.output.md.json
deleted file mode 100644
index c4109240d..000000000
--- a/test/fixture/simple-triplestar.output.md.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/simple-two.output.json b/test/fixture/simple-two.output.json
deleted file mode 100644
index abf774182..000000000
--- a/test/fixture/simple-two.output.json
+++ /dev/null
@@ -1,245 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number plus two.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "the number",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- },
- "name": "a"
- },
- {
- "title": "returns",
- "description": "numbertwo",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- {
- "title": "example",
- "description": "var result = returnTwo(4);\n// result is 6",
- "lineNumber": 5
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 13,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "a",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numbertwo",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "examples": [
- {
- "description": "var result = returnTwo(4);\n// result is 6"
- }
- ],
- "name": "returnTwo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "returnTwo",
- "kind": "function"
- }
- ],
- "namespace": "returnTwo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/simple-two.output.md b/test/fixture/simple-two.output.md
deleted file mode 100644
index c19dd2ab7..000000000
--- a/test/fixture/simple-two.output.md
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-# returnTwo
-
-This function returns the number plus two.
-
-**Parameters**
-
-- `a` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** the number
-
-**Examples**
-
-```javascript
-var result = returnTwo(4);
-// result is 6
-```
-
-Returns **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numbertwo
diff --git a/test/fixture/simple-two.output.md.json b/test/fixture/simple-two.output.md.json
deleted file mode 100644
index 63e64f430..000000000
--- a/test/fixture/simple-two.output.md.json
+++ /dev/null
@@ -1,220 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "returnTwo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number plus two.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Examples"
- }
- ]
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "var result = returnTwo(4);\n// result is 6"
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numbertwo",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/simple.output.github.json b/test/fixture/simple.output.github.json
deleted file mode 100644
index 20b5cc7d9..000000000
--- a/test/fixture/simple.output.github.json
+++ /dev/null
@@ -1,165 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 2
- }
- },
- "github": "[github]",
- "path": "test/fixture/simple.input.js"
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "simple.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "simple.input",
- "kind": "function"
- }
- ],
- "namespace": "simple.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/simple.output.github.md b/test/fixture/simple.output.github.md
deleted file mode 100644
index 69a6336a1..000000000
--- a/test/fixture/simple.output.github.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-# simple.input
-
-[test/fixture/simple.input.js:5-8]([github] "Source code on GitHub")
-
-This function returns the number one.
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/simple.output.json b/test/fixture/simple.output.json
deleted file mode 100644
index ee6fd4cc9..000000000
--- a/test/fixture/simple.output.json
+++ /dev/null
@@ -1,163 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 2
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "simple.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "simple.input",
- "kind": "function"
- }
- ],
- "namespace": "simple.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/simple.output.md b/test/fixture/simple.output.md
deleted file mode 100644
index 55ce13e20..000000000
--- a/test/fixture/simple.output.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-# simple.input
-
-This function returns the number one.
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/simple.output.md.json b/test/fixture/simple.output.md.json
deleted file mode 100644
index 6f30c7d2d..000000000
--- a/test/fixture/simple.output.md.json
+++ /dev/null
@@ -1,118 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "simple.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sort-order-alpha.output.json b/test/fixture/sort-order-alpha.output.json
deleted file mode 100644
index 9d9257b5c..000000000
--- a/test/fixture/sort-order-alpha.output.json
+++ /dev/null
@@ -1,542 +0,0 @@
-[
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 6,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 7,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 15
- }
- }
- },
- "errors": [],
- "name": "a",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "a",
- "kind": "function"
- }
- ],
- "namespace": "a"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 15
- }
- }
- },
- "errors": [],
- "name": "b",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "b",
- "kind": "function"
- }
- ],
- "namespace": "b"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 9,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 19,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "C",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 17,
- "column": 2
- },
- "end": {
- "line": 17,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 18,
- "column": 2
- },
- "end": {
- "line": 18,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "A",
- "kind": "function",
- "memberof": "C",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "C",
- "kind": "class"
- },
- {
- "name": "A",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "C#A"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 15,
- "column": 2
- },
- "end": {
- "line": 15,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 16,
- "column": 2
- },
- "end": {
- "line": 16,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "a",
- "kind": "function",
- "memberof": "C",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "C",
- "kind": "class"
- },
- {
- "name": "a",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "C#a"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 13,
- "column": 2
- },
- "end": {
- "line": 13,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 14,
- "column": 2
- },
- "end": {
- "line": 14,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "B",
- "kind": "function",
- "memberof": "C",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "C",
- "kind": "class"
- },
- {
- "name": "B",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "C#B"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 11,
- "column": 2
- },
- "end": {
- "line": 11,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 12,
- "column": 2
- },
- "end": {
- "line": 12,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "b",
- "kind": "function",
- "memberof": "C",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "C",
- "kind": "class"
- },
- {
- "name": "b",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "C#b"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "C",
- "kind": "class"
- }
- ],
- "namespace": "C"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 21,
- "column": 0
- },
- "end": {
- "line": 21,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 22,
- "column": 0
- },
- "end": {
- "line": 31,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "D",
- "kind": "class",
- "members": {
- "instance": [
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 29,
- "column": 2
- },
- "end": {
- "line": 29,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 30,
- "column": 2
- },
- "end": {
- "line": 30,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "A",
- "kind": "function",
- "memberof": "D",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "D",
- "kind": "class"
- },
- {
- "name": "A",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "D#A"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 27,
- "column": 2
- },
- "end": {
- "line": 27,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 28,
- "column": 2
- },
- "end": {
- "line": 28,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "a",
- "kind": "function",
- "memberof": "D",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "D",
- "kind": "class"
- },
- {
- "name": "a",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "D#a"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 25,
- "column": 2
- },
- "end": {
- "line": 25,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 26,
- "column": 2
- },
- "end": {
- "line": 26,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "B",
- "kind": "function",
- "memberof": "D",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "D",
- "kind": "class"
- },
- {
- "name": "B",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "D#B"
- },
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 23,
- "column": 2
- },
- "end": {
- "line": 23,
- "column": 8
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 24,
- "column": 2
- },
- "end": {
- "line": 24,
- "column": 8
- }
- }
- },
- "errors": [],
- "name": "b",
- "kind": "function",
- "memberof": "D",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "D",
- "kind": "class"
- },
- {
- "name": "b",
- "kind": "function",
- "scope": "instance"
- }
- ],
- "namespace": "D#b"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "D",
- "kind": "class"
- }
- ],
- "namespace": "D"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sort-order-alpha.output.md b/test/fixture/sort-order-alpha.output.md
deleted file mode 100644
index 52350ab59..000000000
--- a/test/fixture/sort-order-alpha.output.md
+++ /dev/null
@@ -1,25 +0,0 @@
-
-
-# a
-
-# b
-
-# C
-
-## A
-
-## a
-
-## B
-
-## b
-
-# D
-
-## A
-
-## a
-
-## B
-
-## b
diff --git a/test/fixture/sort-order-alpha.output.md.json b/test/fixture/sort-order-alpha.output.md.json
deleted file mode 100644
index fe0781da4..000000000
--- a/test/fixture/sort-order-alpha.output.md.json
+++ /dev/null
@@ -1,129 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "a"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "b"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "C"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "A"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "a"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "B"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "b"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "D"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "A"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "a"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "B"
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "b"
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/string-literal-key.output.json b/test/fixture/string-literal-key.output.json
deleted file mode 100644
index 6396ac2c9..000000000
--- a/test/fixture/string-literal-key.output.json
+++ /dev/null
@@ -1,139 +0,0 @@
-[
- {
- "description": "",
- "tags": [
- {
- "title": "alias",
- "description": null,
- "lineNumber": 1,
- "name": "MyContainerObject"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 11,
- "column": 1
- }
- }
- },
- "errors": [],
- "alias": "MyContainerObject",
- "name": "MyContainerObject",
- "kind": "constant",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "MyContainerObject",
- "kind": "constant"
- }
- ],
- "namespace": "MyContainerObject"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The foo property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 5,
- "column": 2
- },
- "end": {
- "line": 7,
- "column": 5
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 8,
- "column": 2
- },
- "end": {
- "line": 10,
- "column": 3
- }
- }
- },
- "errors": [],
- "name": "foo",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "foo"
- }
- ],
- "namespace": "foo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/string-literal-key.output.md b/test/fixture/string-literal-key.output.md
deleted file mode 100644
index cbd81f9fb..000000000
--- a/test/fixture/string-literal-key.output.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-# MyContainerObject
-
-# foo
-
-The foo property
diff --git a/test/fixture/string-literal-key.output.md.json b/test/fixture/string-literal-key.output.md.json
deleted file mode 100644
index 17d559b4b..000000000
--- a/test/fixture/string-literal-key.output.md.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "MyContainerObject"
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "foo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The foo property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/alias.input.js b/test/fixture/sync/alias.input.js
deleted file mode 100644
index 61bd4d81f..000000000
--- a/test/fixture/sync/alias.input.js
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * This is a method that has an alias tag: so it should
- * be referred to as nixon, but should still have inference.
- * @alias nixon
- */
-function dewey(a: number): number {
- return a;
-}
diff --git a/test/fixture/sync/alias.output.json b/test/fixture/sync/alias.output.json
deleted file mode 100644
index 51d67f58e..000000000
--- a/test/fixture/sync/alias.output.json
+++ /dev/null
@@ -1,124 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a method that has an alias tag: so it should\nbe referred to as nixon, but should still have inference.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 58,
- "offset": 110
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 58,
- "offset": 110
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 58,
- "offset": 110
- }
- }
- },
- "tags": [
- {
- "title": "alias",
- "description": null,
- "lineNumber": 3,
- "name": "nixon"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 6,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 1
- }
- }
- },
- "errors": [],
- "alias": "nixon",
- "name": "nixon",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "a",
- "lineNumber": 6,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "nixon",
- "kind": "function"
- }
- ],
- "namespace": "nixon"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/alias.output.md b/test/fixture/sync/alias.output.md
deleted file mode 100644
index 1aabd86f5..000000000
--- a/test/fixture/sync/alias.output.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
-
-# nixon
-
-This is a method that has an alias tag: so it should
-be referred to as nixon, but should still have inference.
-
-**Parameters**
-
-- `a` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
diff --git a/test/fixture/sync/alias.output.md.json b/test/fixture/sync/alias.output.md.json
deleted file mode 100644
index 1e92a953d..000000000
--- a/test/fixture/sync/alias.output.md.json
+++ /dev/null
@@ -1,140 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "nixon"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This is a method that has an alias tag: so it should\nbe referred to as nixon, but should still have inference.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 58,
- "offset": 110
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 58,
- "offset": 110
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/empty-example.input.js b/test/fixture/sync/empty-example.input.js
deleted file mode 100644
index e0922f4ea..000000000
--- a/test/fixture/sync/empty-example.input.js
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * This function returns the number plus two.
- *
- * @example
- */
-function returnTwo() {
- return a + 2;
-}
diff --git a/test/fixture/sync/empty-example.output.json b/test/fixture/sync/empty-example.output.json
deleted file mode 100644
index a6dc7618a..000000000
--- a/test/fixture/sync/empty-example.output.json
+++ /dev/null
@@ -1,104 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number plus two.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- }
- }
- },
- "tags": [
- {
- "title": "example",
- "description": "",
- "lineNumber": 3
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 6,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 1
- }
- }
- },
- "errors": [
- {
- "message": "@example without code",
- "commentLineNumber": 3
- }
- ],
- "name": "returnTwo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "returnTwo",
- "kind": "function"
- }
- ],
- "namespace": "returnTwo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/empty-example.output.md b/test/fixture/sync/empty-example.output.md
deleted file mode 100644
index de994437e..000000000
--- a/test/fixture/sync/empty-example.output.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-# returnTwo
-
-This function returns the number plus two.
diff --git a/test/fixture/sync/empty-example.output.md.json b/test/fixture/sync/empty-example.output.md.json
deleted file mode 100644
index 6cb4a8eb6..000000000
--- a/test/fixture/sync/empty-example.output.md.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "returnTwo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number plus two.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/flow-types.input.js b/test/fixture/sync/flow-types.input.js
deleted file mode 100644
index cfcc9cb4a..000000000
--- a/test/fixture/sync/flow-types.input.js
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * This function returns the number one.
- */
-function addThem(a: Point, b: string, c: ?boolean, d: Array, e: Object, f: Named): number {
- return a + b + c + d + e;
-}
-
-/**
- * A 2D point.
- *
- * @property {number} x this is a prop
- */
-type Point = {
- x: number,
- y: number,
- rgb: {
- hex: string
- },
- props: {
- radius: {
- x: number
- }
- }
-};
-
-/**
- * A type with entirely derived properties
- */
-type Two = {
- x: number,
- y: number,
- z: ?number
-};
-
-/**
- * Just an alias for an array of strings
- */
-type T = Array;
-
-/**
- * Very Important Transform
- */
-function veryImportantTransform(
- input: Array,
- options: Object = {}
-): string {
- return "42";
-}
-
-
-/**
- * Function with optional parameter.
- */
-function optionalFunc(x: number = 42) {}
-
-/**
- * Function with object parameter.
- */
-function objectParamFn(x: { a: number }) {}
-
-/** hi */
-function objectParamFn(x: (y:Foo) => Bar) {}
diff --git a/test/fixture/sync/flow-types.output.json b/test/fixture/sync/flow-types.output.json
deleted file mode 100644
index 35304499f..000000000
--- a/test/fixture/sync/flow-types.output.json
+++ /dev/null
@@ -1,1214 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "addThem",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "a",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Point"
- }
- },
- {
- "title": "param",
- "name": "b",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- },
- {
- "title": "param",
- "name": "c",
- "lineNumber": 4,
- "type": {
- "type": "NullableType",
- "expression": {
- "type": "NameExpression",
- "name": "boolean"
- }
- }
- },
- {
- "title": "param",
- "name": "d",
- "lineNumber": 4,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "number"
- }
- ]
- }
- },
- {
- "title": "param",
- "name": "e",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- {
- "title": "param",
- "name": "f",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Named"
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "addThem",
- "kind": "function"
- }
- ],
- "namespace": "addThem"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A 2D point.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- }
- }
- },
- "tags": [
- {
- "title": "property",
- "description": "this is a prop",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "x"
- }
- ],
- "loc": {
- "start": {
- "line": 8,
- "column": 0
- },
- "end": {
- "line": 12,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 0
- },
- "end": {
- "line": 24,
- "column": 2
- }
- }
- },
- "errors": [],
- "properties": [
- {
- "name": "x",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "this is a prop",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "title": "property",
- "name": "y",
- "lineNumber": 15,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "title": "property",
- "name": "rgb",
- "lineNumber": 16,
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "hex",
- "value": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ]
- },
- "properties": [
- {
- "title": "property",
- "name": "rgb.hex",
- "lineNumber": 17,
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ]
- },
- {
- "title": "property",
- "name": "props",
- "lineNumber": 19,
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "radius",
- "value": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "x",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- }
- }
- ]
- },
- "properties": [
- {
- "title": "property",
- "name": "props.radius",
- "lineNumber": 20,
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "x",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- },
- "properties": [
- {
- "title": "property",
- "name": "props.radius.x",
- "lineNumber": 21,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- }
- ]
- }
- ],
- "name": "Point",
- "kind": "typedef",
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "x",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "type": "FieldType",
- "key": "y",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "type": "FieldType",
- "key": "rgb",
- "value": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "hex",
- "value": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ]
- }
- },
- {
- "type": "FieldType",
- "key": "props",
- "value": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "radius",
- "value": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "x",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- }
- }
- ]
- }
- }
- ]
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Point",
- "kind": "typedef"
- }
- ],
- "namespace": "Point"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A type with entirely derived properties",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 26,
- "column": 0
- },
- "end": {
- "line": 28,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 29,
- "column": 0
- },
- "end": {
- "line": 33,
- "column": 2
- }
- }
- },
- "errors": [],
- "name": "Two",
- "kind": "typedef",
- "properties": [
- {
- "title": "property",
- "name": "x",
- "lineNumber": 30,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "title": "property",
- "name": "y",
- "lineNumber": 31,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "title": "property",
- "name": "z",
- "lineNumber": 32,
- "type": {
- "type": "NullableType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- }
- ],
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "x",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "type": "FieldType",
- "key": "y",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "type": "FieldType",
- "key": "z",
- "value": {
- "type": "NullableType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- }
- ]
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Two",
- "kind": "typedef"
- }
- ],
- "namespace": "Two"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Just an alias for an array of strings",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 35,
- "column": 0
- },
- "end": {
- "line": 37,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 38,
- "column": 0
- },
- "end": {
- "line": 38,
- "column": 23
- }
- }
- },
- "errors": [],
- "name": "T",
- "kind": "typedef",
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "string"
- }
- ]
- },
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "T",
- "kind": "typedef"
- }
- ],
- "namespace": "T"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Very Important Transform",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 40,
- "column": 0
- },
- "end": {
- "line": 42,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 43,
- "column": 0
- },
- "end": {
- "line": 48,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "veryImportantTransform",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "input",
- "lineNumber": 44,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "string"
- }
- ]
- }
- },
- {
- "title": "param",
- "name": "options",
- "default": "{}",
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "veryImportantTransform",
- "kind": "function"
- }
- ],
- "namespace": "veryImportantTransform"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Function with optional parameter.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 51,
- "column": 0
- },
- "end": {
- "line": 53,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 54,
- "column": 0
- },
- "end": {
- "line": 54,
- "column": 40
- }
- }
- },
- "errors": [],
- "name": "optionalFunc",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "x",
- "default": "42",
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "optionalFunc",
- "kind": "function"
- }
- ],
- "namespace": "optionalFunc"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Function with object parameter.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 56,
- "column": 0
- },
- "end": {
- "line": 58,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 59,
- "column": 0
- },
- "end": {
- "line": 59,
- "column": 43
- }
- }
- },
- "errors": [],
- "name": "objectParamFn",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "x",
- "lineNumber": 59,
- "type": {
- "type": "RecordType",
- "fields": [
- {
- "type": "FieldType",
- "key": "a",
- "value": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ]
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "objectParamFn",
- "kind": "function"
- }
- ],
- "namespace": "objectParamFn"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "hi",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 3,
- "offset": 2
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 3,
- "offset": 2
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 3,
- "offset": 2
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 61,
- "column": 0
- },
- "end": {
- "line": 61,
- "column": 9
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 62,
- "column": 0
- },
- "end": {
- "line": 62,
- "column": 44
- }
- }
- },
- "errors": [],
- "name": "objectParamFn",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "x",
- "lineNumber": 62,
- "type": {
- "type": "FunctionType",
- "params": [
- {
- "type": "ParameterType",
- "name": "y",
- "expression": {
- "type": "NameExpression",
- "name": "Foo"
- }
- }
- ],
- "result": {
- "type": "NameExpression",
- "name": "Bar"
- }
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "objectParamFn",
- "kind": "function"
- }
- ],
- "namespace": "objectParamFn"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/flow-types.output.md b/test/fixture/sync/flow-types.output.md
deleted file mode 100644
index ae907df12..000000000
--- a/test/fixture/sync/flow-types.output.md
+++ /dev/null
@@ -1,79 +0,0 @@
-
-
-# addThem
-
-This function returns the number one.
-
-**Parameters**
-
-- `a` **[Point](#point)**
-- `b` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**
-- `c` **[boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?**
-- `d` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>**
-- `e` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)**
-- `f` **Named**
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-
-# Point
-
-A 2D point.
-
-**Properties**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** this is a prop
-- `y` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-- `rgb` **{hex: [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)}**
- - `rgb.hex` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**
-- `props` **{radius: {x: [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)}}**
- - `props.radius` **{x: [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)}**
- - `props.radius.x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-
-# Two
-
-A type with entirely derived properties
-
-**Properties**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-- `y` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-- `z` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?**
-
-# T
-
-Just an alias for an array of strings
-
-# veryImportantTransform
-
-Very Important Transform
-
-**Parameters**
-
-- `input` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)>**
-- `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)?** (optional, default `{}`)
-
-Returns **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**
-
-# optionalFunc
-
-Function with optional parameter.
-
-**Parameters**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** (optional, default `42`)
-
-# objectParamFn
-
-Function with object parameter.
-
-**Parameters**
-
-- `x` **{a: [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)}**
-
-# objectParamFn
-
-hi
-
-**Parameters**
-
-- `x` **function (y: Foo): Bar**
diff --git a/test/fixture/sync/flow-types.output.md.json b/test/fixture/sync/flow-types.output.md.json
deleted file mode 100644
index 0a303ae91..000000000
--- a/test/fixture/sync/flow-types.output.md.json
+++ /dev/null
@@ -1,1537 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "addThem"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "#point",
- "url": "#point",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Point"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "b"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "c"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "boolean"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "d"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "e"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "f"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Named"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Point"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A 2D point.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 12,
- "offset": 11
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "this is a prop",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "y"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "rgb"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "{"
- },
- {
- "type": "text",
- "value": "hex: "
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- },
- {
- "type": "text",
- "value": "}"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "rgb.hex"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "props"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "{"
- },
- {
- "type": "text",
- "value": "radius: "
- },
- {
- "type": "text",
- "value": "{"
- },
- {
- "type": "text",
- "value": "x: "
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "}"
- },
- {
- "type": "text",
- "value": "}"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "props.radius"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "{"
- },
- {
- "type": "text",
- "value": "x: "
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "}"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "props.radius.x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Two"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A type with entirely derived properties",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 40,
- "offset": 39
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "y"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "z"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "T"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Just an alias for an array of strings",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "veryImportantTransform"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Very Important Transform",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "input"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "{}"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "optionalFunc"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Function with optional parameter.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "42"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "objectParamFn"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Function with object parameter.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 32,
- "offset": 31
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "{"
- },
- {
- "type": "text",
- "value": "a: "
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- },
- {
- "type": "text",
- "value": "}"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "objectParamFn"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "hi",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 3,
- "offset": 2
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 3,
- "offset": 2
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "function ("
- },
- {
- "type": "text",
- "value": "y: "
- },
- {
- "type": "text",
- "value": "Foo"
- },
- {
- "type": "text",
- "value": ")"
- },
- {
- "type": "text",
- "value": ": "
- },
- {
- "type": "text",
- "value": "Bar"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/lots-of-options.input.js b/test/fixture/sync/lots-of-options.input.js
deleted file mode 100644
index c9f32290e..000000000
--- a/test/fixture/sync/lots-of-options.input.js
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * Global spectra deconvolution
- * @param {Array} x - Independent variable
- * @param {Array} yIn - Dependent variable
- * @param {Object} [options] - Options object
- * @param {Object} [options.sgOptions] - Options object for Savitzky-Golay filter. See https://github.com/mljs/savitzky-golay-generalized#options
- * @param {Number} [options.minMaxRatio = 0.00025] - Threshold to determine if a given peak should be considered as a noise
- * @param {Number} [options.broadRatio = 0.00] - If `broadRatio` is higher than 0, then all the peaks which second derivative
- * smaller than `broadRatio * maxAbsSecondDerivative` will be marked with the soft mask equal to true.
- * @param {Number} [options.noiseLevel = 3] - Noise threshold in spectrum units
- * @param {Boolean} [options.maxCriteria = true] - Peaks are local maximum(true) or minimum(false)
- * @param {Boolean} [options.smoothY = true] - Select the peak intensities from a smoothed version of the independent variables
- * @param {Boolean} [options.realTopDetection = false] - Use a quadratic optimizations with the peak and its 3 closest neighbors
- * to determine the true x,y values of the peak?
- * @param {Number} [options.heightFactor = 0] - Factor to multiply the calculated height (usually 2)
- * @param {Boolean} [options.boundaries = false] - Return also the inflection points of the peaks
- * @param {Number} [options.derivativeThreshold = 0] - Filters based on the amplitude of the first derivative
- * @return {Array}
- */
-function gsd(x, yIn, options) {
-}
-
-module.exports = gsd;
diff --git a/test/fixture/sync/lots-of-options.output.json b/test/fixture/sync/lots-of-options.output.json
deleted file mode 100644
index e140f0dca..000000000
--- a/test/fixture/sync/lots-of-options.output.json
+++ /dev/null
@@ -1,1292 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Global spectra deconvolution",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "Independent variable",
- "lineNumber": 2,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Number"
- }
- ]
- },
- "name": "x"
- },
- {
- "title": "param",
- "description": "Dependent variable",
- "lineNumber": 3,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Number"
- }
- ]
- },
- "name": "yIn"
- },
- {
- "title": "param",
- "description": "Options object",
- "lineNumber": 4,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- "name": "options"
- },
- {
- "title": "param",
- "description": "Options object for Savitzky-Golay filter. See https://github.com/mljs/savitzky-golay-generalized#options",
- "lineNumber": 5,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- "name": "options.sgOptions"
- },
- {
- "title": "param",
- "description": "Threshold to determine if a given peak should be considered as a noise",
- "lineNumber": 6,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "name": "options.minMaxRatio",
- "default": "0.00025"
- },
- {
- "title": "param",
- "description": "If `broadRatio` is higher than 0, then all the peaks which second derivative\nsmaller than `broadRatio * maxAbsSecondDerivative` will be marked with the soft mask equal to true.",
- "lineNumber": 7,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "name": "options.broadRatio",
- "default": "0.00"
- },
- {
- "title": "param",
- "description": "Noise threshold in spectrum units",
- "lineNumber": 9,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "name": "options.noiseLevel",
- "default": "3"
- },
- {
- "title": "param",
- "description": "Peaks are local maximum(true) or minimum(false)",
- "lineNumber": 10,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "name": "options.maxCriteria",
- "default": "true"
- },
- {
- "title": "param",
- "description": "Select the peak intensities from a smoothed version of the independent variables",
- "lineNumber": 11,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "name": "options.smoothY",
- "default": "true"
- },
- {
- "title": "param",
- "description": "Use a quadratic optimizations with the peak and its 3 closest neighbors\nto determine the true x,y values of the peak?",
- "lineNumber": 12,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "name": "options.realTopDetection",
- "default": "false"
- },
- {
- "title": "param",
- "description": "Factor to multiply the calculated height (usually 2)",
- "lineNumber": 14,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "name": "options.heightFactor",
- "default": "0"
- },
- {
- "title": "param",
- "description": "Return also the inflection points of the peaks",
- "lineNumber": 15,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "name": "options.boundaries",
- "default": "false"
- },
- {
- "title": "param",
- "description": "Filters based on the amplitude of the first derivative",
- "lineNumber": 16,
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "name": "options.derivativeThreshold",
- "default": "0"
- },
- {
- "title": "return",
- "description": null,
- "lineNumber": 17,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Object"
- }
- ]
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 19,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 20,
- "column": 0
- },
- "end": {
- "line": 21,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "x",
- "lineNumber": 2,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Independent variable",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- }
- }
- },
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Number"
- }
- ]
- }
- },
- {
- "name": "yIn",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Dependent variable",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- }
- }
- },
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Number"
- }
- ]
- }
- },
- {
- "name": "options",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Options object",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- },
- "properties": [
- {
- "name": "options.sgOptions",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Options object for Savitzky-Golay filter. See ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "indent": []
- }
- },
- {
- "type": "link",
- "title": null,
- "url": "https://github.com/mljs/savitzky-golay-generalized#options",
- "children": [
- {
- "type": "text",
- "value": "https://github.com/mljs/savitzky-golay-generalized#options",
- "position": {
- "start": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Object"
- }
- }
- },
- {
- "name": "options.minMaxRatio",
- "lineNumber": 6,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Threshold to determine if a given peak should be considered as a noise",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 71,
- "offset": 70
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 71,
- "offset": 70
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 71,
- "offset": 70
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "default": "0.00025"
- },
- {
- "name": "options.broadRatio",
- "lineNumber": 7,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "If ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "broadRatio",
- "position": {
- "start": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " is higher than 0, then all the peaks which second derivative\nsmaller than ",
- "position": {
- "start": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "end": {
- "line": 2,
- "column": 14,
- "offset": 90
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "inlineCode",
- "value": "broadRatio * maxAbsSecondDerivative",
- "position": {
- "start": {
- "line": 2,
- "column": 14,
- "offset": 90
- },
- "end": {
- "line": 2,
- "column": 51,
- "offset": 127
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " will be marked with the soft mask equal to true.",
- "position": {
- "start": {
- "line": 2,
- "column": 51,
- "offset": 127
- },
- "end": {
- "line": 2,
- "column": 100,
- "offset": 176
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 100,
- "offset": 176
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 100,
- "offset": 176
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "default": "0.00"
- },
- {
- "name": "options.noiseLevel",
- "lineNumber": 9,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Noise threshold in spectrum units",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "default": "3"
- },
- {
- "name": "options.maxCriteria",
- "lineNumber": 10,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Peaks are local maximum(true) or minimum(false)",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "default": "true"
- },
- {
- "name": "options.smoothY",
- "lineNumber": 11,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Select the peak intensities from a smoothed version of the independent variables",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 81,
- "offset": 80
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 81,
- "offset": 80
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 81,
- "offset": 80
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "default": "true"
- },
- {
- "name": "options.realTopDetection",
- "lineNumber": 12,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Use a quadratic optimizations with the peak and its 3 closest neighbors\nto determine the true x,y values of the peak?",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 46,
- "offset": 117
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 46,
- "offset": 117
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 46,
- "offset": 117
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "default": "false"
- },
- {
- "name": "options.heightFactor",
- "lineNumber": 14,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Factor to multiply the calculated height (usually 2)",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "default": "0"
- },
- {
- "name": "options.boundaries",
- "lineNumber": 15,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Return also the inflection points of the peaks",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Boolean"
- }
- },
- "default": "false"
- },
- {
- "name": "options.derivativeThreshold",
- "lineNumber": 16,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Filters based on the amplitude of the first derivative",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- }
- }
- },
- "type": {
- "type": "OptionalType",
- "expression": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- "default": "0"
- }
- ]
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 1,
- "offset": 0
- }
- }
- },
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "Object"
- }
- ]
- }
- }
- ],
- "name": "gsd",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "gsd",
- "kind": "function"
- }
- ],
- "namespace": "gsd"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/lots-of-options.output.md b/test/fixture/sync/lots-of-options.output.md
deleted file mode 100644
index 55321bdcb..000000000
--- a/test/fixture/sync/lots-of-options.output.md
+++ /dev/null
@@ -1,25 +0,0 @@
-
-
-# gsd
-
-Global spectra deconvolution
-
-**Parameters**
-
-- `x` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>** Independent variable
-- `yIn` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>** Dependent variable
-- `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)?** Options object
- - `options.sgOptions` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)?** Options object for Savitzky-Golay filter. See
- - `options.minMaxRatio` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Threshold to determine if a given peak should be considered as a noise (optional, default `0.00025`)
- - `options.broadRatio` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** If `broadRatio` is higher than 0, then all the peaks which second derivative
- smaller than `broadRatio * maxAbsSecondDerivative` will be marked with the soft mask equal to true. (optional, default `0.00`)
- - `options.noiseLevel` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Noise threshold in spectrum units (optional, default `3`)
- - `options.maxCriteria` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Peaks are local maximum(true) or minimum(false) (optional, default `true`)
- - `options.smoothY` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Select the peak intensities from a smoothed version of the independent variables (optional, default `true`)
- - `options.realTopDetection` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Use a quadratic optimizations with the peak and its 3 closest neighbors
- to determine the true x,y values of the peak? (optional, default `false`)
- - `options.heightFactor` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Factor to multiply the calculated height (usually 2) (optional, default `0`)
- - `options.boundaries` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Return also the inflection points of the peaks (optional, default `false`)
- - `options.derivativeThreshold` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Filters based on the amplitude of the first derivative (optional, default `0`)
-
-Returns **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)>**
diff --git a/test/fixture/sync/lots-of-options.output.md.json b/test/fixture/sync/lots-of-options.output.md.json
deleted file mode 100644
index 0be407f12..000000000
--- a/test/fixture/sync/lots-of-options.output.md.json
+++ /dev/null
@@ -1,1420 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "gsd"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Global spectra deconvolution",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 29,
- "offset": 28
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Independent variable",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 21,
- "offset": 20
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "yIn"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Dependent variable",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Options object",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.sgOptions"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Options object for Savitzky-Golay filter. See ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "indent": []
- }
- },
- {
- "type": "link",
- "title": null,
- "url": "https://github.com/mljs/savitzky-golay-generalized#options",
- "children": [
- {
- "type": "text",
- "value": "https://github.com/mljs/savitzky-golay-generalized#options",
- "position": {
- "start": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 105,
- "offset": 104
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.minMaxRatio"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Threshold to determine if a given peak should be considered as a noise",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 71,
- "offset": 70
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 71,
- "offset": 70
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "0.00025"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.broadRatio"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "If ",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- },
- {
- "type": "inlineCode",
- "value": "broadRatio",
- "position": {
- "start": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "end": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " is higher than 0, then all the peaks which second derivative\nsmaller than ",
- "position": {
- "start": {
- "line": 1,
- "column": 16,
- "offset": 15
- },
- "end": {
- "line": 2,
- "column": 14,
- "offset": 90
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "inlineCode",
- "value": "broadRatio * maxAbsSecondDerivative",
- "position": {
- "start": {
- "line": 2,
- "column": 14,
- "offset": 90
- },
- "end": {
- "line": 2,
- "column": 51,
- "offset": 127
- },
- "indent": []
- }
- },
- {
- "type": "text",
- "value": " will be marked with the soft mask equal to true.",
- "position": {
- "start": {
- "line": 2,
- "column": 51,
- "offset": 127
- },
- "end": {
- "line": 2,
- "column": 100,
- "offset": 176
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 100,
- "offset": 176
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "0.00"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.noiseLevel"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Noise threshold in spectrum units",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 34,
- "offset": 33
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "3"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.maxCriteria"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Boolean"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Peaks are local maximum(true) or minimum(false)",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 48,
- "offset": 47
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "true"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.smoothY"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Boolean"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Select the peak intensities from a smoothed version of the independent variables",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 81,
- "offset": 80
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 81,
- "offset": 80
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "true"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.realTopDetection"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Boolean"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Use a quadratic optimizations with the peak and its 3 closest neighbors\nto determine the true x,y values of the peak?",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 46,
- "offset": 117
- },
- "indent": [
- 1
- ]
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 2,
- "column": 46,
- "offset": 117
- },
- "indent": [
- 1
- ]
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "false"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.heightFactor"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Factor to multiply the calculated height (usually 2)",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 53,
- "offset": 52
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "0"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.boundaries"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Boolean"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Return also the inflection points of the peaks",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 47,
- "offset": 46
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "false"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "options.derivativeThreshold"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- },
- {
- "type": "text",
- "value": "?"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Filters based on the amplitude of the first derivative",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 55,
- "offset": 54
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": " (optional, default "
- },
- {
- "type": "inlineCode",
- "value": "0"
- },
- {
- "type": "text",
- "value": ")"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Object"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/meta.input.js b/test/fixture/sync/meta.input.js
deleted file mode 100644
index 9718fbee9..000000000
--- a/test/fixture/sync/meta.input.js
+++ /dev/null
@@ -1,11 +0,0 @@
-/**
- * This function has a lot of metadata
- * @version 1.2.0
- * @author Jim Jones
- * @copyright John Jones
- * @since 1962
- * @license Public Domain
- */
-function dewey(a) {
- return a;
-}
diff --git a/test/fixture/sync/meta.output.json b/test/fixture/sync/meta.output.json
deleted file mode 100644
index 4cc0998e2..000000000
--- a/test/fixture/sync/meta.output.json
+++ /dev/null
@@ -1,182 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function has a lot of metadata",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- }
- }
- },
- "tags": [
- {
- "title": "version",
- "description": "1.2.0",
- "lineNumber": 2
- },
- {
- "title": "author",
- "description": "Jim Jones",
- "lineNumber": 3
- },
- {
- "title": "copyright",
- "description": "John Jones",
- "lineNumber": 4
- },
- {
- "title": "since",
- "description": "1962",
- "lineNumber": 5
- },
- {
- "title": "license",
- "description": "Public Domain",
- "lineNumber": 6
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 9,
- "column": 0
- },
- "end": {
- "line": 11,
- "column": 1
- }
- }
- },
- "errors": [],
- "version": "1.2.0",
- "author": "Jim Jones",
- "copyright": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "John Jones",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- }
- }
- },
- "since": "1962",
- "license": "Public Domain",
- "name": "dewey",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "a",
- "lineNumber": 9
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "dewey",
- "kind": "function"
- }
- ],
- "namespace": "dewey"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/meta.output.md b/test/fixture/sync/meta.output.md
deleted file mode 100644
index 97c676fbf..000000000
--- a/test/fixture/sync/meta.output.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-# dewey
-
-This function has a lot of metadata
-
-**Parameters**
-
-- `a`
-
-**Meta**
-
-- **version**: 1.2.0
-- **since**: 1962
-- **copyright**: \[object Object]
-- **author**: Jim Jones
-- **license**: Public Domain
diff --git a/test/fixture/sync/meta.output.md.json b/test/fixture/sync/meta.output.md.json
deleted file mode 100644
index d2fb3424a..000000000
--- a/test/fixture/sync/meta.output.md.json
+++ /dev/null
@@ -1,221 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "dewey"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function has a lot of metadata",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 36,
- "offset": 35
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Meta"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "version"
- }
- ]
- },
- {
- "type": "text",
- "value": ": 1.2.0"
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "since"
- }
- ]
- },
- {
- "type": "text",
- "value": ": 1962"
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "copyright"
- }
- ]
- },
- {
- "type": "text",
- "value": ": [object Object]"
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "author"
- }
- ]
- },
- {
- "type": "text",
- "value": ": Jim Jones"
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "license"
- }
- ]
- },
- {
- "type": "text",
- "value": ": Public Domain"
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/multiexample.input.js b/test/fixture/sync/multiexample.input.js
deleted file mode 100644
index 88227f4df..000000000
--- a/test/fixture/sync/multiexample.input.js
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * This function returns the number one.
- * @returns {Number} numberone
- * @example
- * foo(1);
- * @example
- * foo(2);
- * @throws {Error} if you give it something
- * @throws {TypeError} if you give it something else
- * @augments Foo
- * @augments Bar
- */
-module.exports = function () {
- // this returns 1
- return 1;
-};
diff --git a/test/fixture/sync/multiexample.output.json b/test/fixture/sync/multiexample.output.json
deleted file mode 100644
index 48fd4a2a7..000000000
--- a/test/fixture/sync/multiexample.output.json
+++ /dev/null
@@ -1,347 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- {
- "title": "example",
- "description": "foo(1);",
- "lineNumber": 3
- },
- {
- "title": "example",
- "description": "foo(2);",
- "lineNumber": 5
- },
- {
- "title": "throws",
- "description": "if you give it something",
- "lineNumber": 7,
- "type": {
- "type": "NameExpression",
- "name": "Error"
- }
- },
- {
- "title": "throws",
- "description": "if you give it something else",
- "lineNumber": 8,
- "type": {
- "type": "NameExpression",
- "name": "TypeError"
- }
- },
- {
- "title": "augments",
- "description": null,
- "lineNumber": 9,
- "type": null,
- "name": "Foo"
- },
- {
- "title": "augments",
- "description": null,
- "lineNumber": 10,
- "type": null,
- "name": "Bar"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 12,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 13,
- "column": 0
- },
- "end": {
- "line": 16,
- "column": 2
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "examples": [
- {
- "description": "foo(1);"
- },
- {
- "description": "foo(2);"
- }
- ],
- "throws": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "if you give it something",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Error"
- }
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "if you give it something else",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 30,
- "offset": 29
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 30,
- "offset": 29
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 30,
- "offset": 29
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "TypeError"
- }
- }
- ],
- "augments": [
- {
- "title": "augments",
- "description": null,
- "lineNumber": 9,
- "type": null,
- "name": "Foo"
- },
- {
- "title": "augments",
- "description": null,
- "lineNumber": 10,
- "type": null,
- "name": "Bar"
- }
- ],
- "name": "multiexample.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "multiexample.input",
- "kind": "function"
- }
- ],
- "namespace": "multiexample.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/multiexample.output.md b/test/fixture/sync/multiexample.output.md
deleted file mode 100644
index 9090b94d4..000000000
--- a/test/fixture/sync/multiexample.output.md
+++ /dev/null
@@ -1,22 +0,0 @@
-
-
-# multiexample.input
-
-**Extends Foo, Bar**
-
-This function returns the number one.
-
-**Examples**
-
-```javascript
-foo(1);
-```
-
-```javascript
-foo(2);
-```
-
-- Throws **[Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)** if you give it something
-- Throws **[TypeError](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError)** if you give it something else
-
-Returns **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/sync/multiexample.output.md.json b/test/fixture/sync/multiexample.output.md.json
deleted file mode 100644
index b08c2dc91..000000000
--- a/test/fixture/sync/multiexample.output.md.json
+++ /dev/null
@@ -1,299 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "multiexample.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Extends "
- },
- {
- "type": "text",
- "value": "Foo, Bar"
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Examples"
- }
- ]
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "foo(1);"
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "foo(2);"
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Throws "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Error"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "if you give it something",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 25,
- "offset": 24
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Throws "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "TypeError"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "if you give it something else",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 30,
- "offset": 29
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 30,
- "offset": 29
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/rename.input.js b/test/fixture/sync/rename.input.js
deleted file mode 100644
index 16599b811..000000000
--- a/test/fixture/sync/rename.input.js
+++ /dev/null
@@ -1,6 +0,0 @@
-/**
- * Cheesoid!
- * @name cheese
- */
-function petrol(): string {
-}
diff --git a/test/fixture/sync/rename.output.json b/test/fixture/sync/rename.output.json
deleted file mode 100644
index 79811ad3c..000000000
--- a/test/fixture/sync/rename.output.json
+++ /dev/null
@@ -1,98 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Cheesoid!",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "tags": [
- {
- "title": "name",
- "description": null,
- "lineNumber": 2,
- "name": "cheese"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 1
- }
- }
- },
- "errors": [],
- "name": "cheese",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "cheese"
- }
- ],
- "namespace": "cheese"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/rename.output.md b/test/fixture/sync/rename.output.md
deleted file mode 100644
index 87c9ed441..000000000
--- a/test/fixture/sync/rename.output.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-# cheese
-
-Cheesoid!
diff --git a/test/fixture/sync/rename.output.md.json b/test/fixture/sync/rename.output.md.json
deleted file mode 100644
index bec4f3a8d..000000000
--- a/test/fixture/sync/rename.output.md.json
+++ /dev/null
@@ -1,54 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "cheese"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Cheesoid!",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/throws.input.js b/test/fixture/sync/throws.input.js
deleted file mode 100644
index 690c20783..000000000
--- a/test/fixture/sync/throws.input.js
+++ /dev/null
@@ -1,15 +0,0 @@
-/**
- * This function returns the number plus two.
- *
- * @param {Number} a the number
- * @returns {Number} numbertwo
- * @throws {Error} if number is 3
- * @example
- * var result = returnTwo(4);
- * // result is 6
- */
-function returnTwo(a) {
- if (a === 3) throw new Error('cannot be 3');
- // this returns a + 2
- return a + 2;
-}
diff --git a/test/fixture/sync/throws.output.json b/test/fixture/sync/throws.output.json
deleted file mode 100644
index 307fcb29b..000000000
--- a/test/fixture/sync/throws.output.json
+++ /dev/null
@@ -1,314 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number plus two.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- }
- }
- },
- "tags": [
- {
- "title": "param",
- "description": "the number",
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- },
- "name": "a"
- },
- {
- "title": "returns",
- "description": "numbertwo",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- },
- {
- "title": "throws",
- "description": "if number is 3",
- "lineNumber": 5,
- "type": {
- "type": "NameExpression",
- "name": "Error"
- }
- },
- {
- "title": "example",
- "description": "var result = returnTwo(4);\n// result is 6",
- "lineNumber": 6
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 10,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 11,
- "column": 0
- },
- "end": {
- "line": 15,
- "column": 1
- }
- }
- },
- "errors": [],
- "params": [
- {
- "name": "a",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numbertwo",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Number"
- }
- }
- ],
- "throws": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "if number is 3",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "Error"
- }
- }
- ],
- "examples": [
- {
- "description": "var result = returnTwo(4);\n// result is 6"
- }
- ],
- "name": "returnTwo",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "returnTwo",
- "kind": "function"
- }
- ],
- "namespace": "returnTwo"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/throws.output.md b/test/fixture/sync/throws.output.md
deleted file mode 100644
index fda184f61..000000000
--- a/test/fixture/sync/throws.output.md
+++ /dev/null
@@ -1,20 +0,0 @@
-
-
-# returnTwo
-
-This function returns the number plus two.
-
-**Parameters**
-
-- `a` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** the number
-
-**Examples**
-
-```javascript
-var result = returnTwo(4);
-// result is 6
-```
-
-- Throws **[Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)** if number is 3
-
-Returns **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numbertwo
diff --git a/test/fixture/sync/throws.output.md.json b/test/fixture/sync/throws.output.md.json
deleted file mode 100644
index a89bee28b..000000000
--- a/test/fixture/sync/throws.output.md.json
+++ /dev/null
@@ -1,295 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "returnTwo"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number plus two.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 43,
- "offset": 42
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "a"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "the number",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 11,
- "offset": 10
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Examples"
- }
- ]
- },
- {
- "lang": "javascript",
- "type": "code",
- "value": "var result = returnTwo(4);\n// result is 6"
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Throws "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Error"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "if number is 3",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numbertwo",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/trailing-only.input.js b/test/fixture/sync/trailing-only.input.js
deleted file mode 100644
index b2571bd84..000000000
--- a/test/fixture/sync/trailing-only.input.js
+++ /dev/null
@@ -1,7 +0,0 @@
-function fooBaz() {
- return 2;
-}
-/**
- * this is a type
- * @returns {number} nothing
- */
diff --git a/test/fixture/sync/trailing-only.output.json b/test/fixture/sync/trailing-only.output.json
deleted file mode 100644
index eaebb188b..000000000
--- a/test/fixture/sync/trailing-only.output.json
+++ /dev/null
@@ -1,162 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "this is a type",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "nothing",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 1
- }
- }
- },
- "errors": [
- {
- "message": "could not determine @name for hierarchy"
- }
- ],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "nothing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {}
- ],
- "namespace": "undefined"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/trailing-only.output.md b/test/fixture/sync/trailing-only.output.md
deleted file mode 100644
index 1997477f4..000000000
--- a/test/fixture/sync/trailing-only.output.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-#
-
-this is a type
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** nothing
diff --git a/test/fixture/sync/trailing-only.output.md.json b/test/fixture/sync/trailing-only.output.md.json
deleted file mode 100644
index ba50618be..000000000
--- a/test/fixture/sync/trailing-only.output.md.json
+++ /dev/null
@@ -1,118 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": ""
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "this is a type",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "nothing",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 8,
- "offset": 7
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/trailing.input.js b/test/fixture/sync/trailing.input.js
deleted file mode 100644
index 5e11b97c0..000000000
--- a/test/fixture/sync/trailing.input.js
+++ /dev/null
@@ -1,18 +0,0 @@
-/**
- * ONE
- * @returns {number} something
- */
-function fooBar() {
- return 1;
-}
-/**
- * TWO
- * @returns {number} something
- */
-function fooBaz() {
- return 2;
-}
-/**
- * this is a type
- * @class Something
- */
diff --git a/test/fixture/sync/trailing.output.json b/test/fixture/sync/trailing.output.json
deleted file mode 100644
index c2bd778d3..000000000
--- a/test/fixture/sync/trailing.output.json
+++ /dev/null
@@ -1,423 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "ONE",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "something",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 1
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "something",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "fooBar",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "fooBar",
- "kind": "function"
- }
- ],
- "namespace": "fooBar"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "TWO",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "something",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 8,
- "column": 0
- },
- "end": {
- "line": 11,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 12,
- "column": 0
- },
- "end": {
- "line": 14,
- "column": 1
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "something",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "fooBaz",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "fooBaz",
- "kind": "function"
- }
- ],
- "namespace": "fooBaz"
- },
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "this is a type",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- }
- }
- },
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 2,
- "type": null,
- "name": "Something"
- }
- ],
- "loc": {
- "start": {
- "line": 15,
- "column": 0
- },
- "end": {
- "line": 18,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 12,
- "column": 0
- },
- "end": {
- "line": 14,
- "column": 1
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "Something",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Something",
- "kind": "class"
- }
- ],
- "namespace": "Something"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/trailing.output.md b/test/fixture/sync/trailing.output.md
deleted file mode 100644
index fbd87c100..000000000
--- a/test/fixture/sync/trailing.output.md
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-# fooBar
-
-ONE
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** something
-
-# fooBaz
-
-TWO
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** something
-
-# Something
-
-this is a type
diff --git a/test/fixture/sync/trailing.output.md.json b/test/fixture/sync/trailing.output.md.json
deleted file mode 100644
index 4858cb671..000000000
--- a/test/fixture/sync/trailing.output.md.json
+++ /dev/null
@@ -1,272 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "fooBar"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "ONE",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "something",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "fooBaz"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "TWO",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 4,
- "offset": 3
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "something",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Something"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "this is a type",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 15,
- "offset": 14
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/sync/typedef.input.js b/test/fixture/sync/typedef.input.js
deleted file mode 100644
index 2747c8de7..000000000
--- a/test/fixture/sync/typedef.input.js
+++ /dev/null
@@ -1,8 +0,0 @@
-/**
- * A type definition.
- * @name MyType
- * @typedef {Object} MyType
- * @property {number} prop1 - one property
- * @property {string} prop2 - another property
- */
-
diff --git a/test/fixture/sync/typedef.output.json b/test/fixture/sync/typedef.output.json
deleted file mode 100644
index d1199fe40..000000000
--- a/test/fixture/sync/typedef.output.json
+++ /dev/null
@@ -1,256 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A type definition.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- }
- }
- },
- "tags": [
- {
- "title": "name",
- "description": null,
- "lineNumber": 2,
- "name": "MyType"
- },
- {
- "title": "typedef",
- "description": null,
- "lineNumber": 3,
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "name": "MyType"
- },
- {
- "title": "property",
- "description": "one property",
- "lineNumber": 4,
- "type": {
- "type": "NameExpression",
- "name": "number"
- },
- "name": "prop1"
- },
- {
- "title": "property",
- "description": "another property",
- "lineNumber": 5,
- "type": {
- "type": "NameExpression",
- "name": "string"
- },
- "name": "prop2"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 0
- }
- }
- },
- "errors": [],
- "name": "MyType",
- "kind": "typedef",
- "type": {
- "type": "NameExpression",
- "name": "Object"
- },
- "properties": [
- {
- "name": "prop1",
- "lineNumber": 4,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "one property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- },
- {
- "name": "prop2",
- "lineNumber": 5,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "another property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "string"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "MyType",
- "kind": "typedef"
- }
- ],
- "namespace": "MyType"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/sync/typedef.output.md b/test/fixture/sync/typedef.output.md
deleted file mode 100644
index e2ed3269d..000000000
--- a/test/fixture/sync/typedef.output.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-
-# MyType
-
-A type definition.
-
-**Properties**
-
-- `prop1` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** one property
-- `prop2` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** another property
diff --git a/test/fixture/sync/typedef.output.md.json b/test/fixture/sync/typedef.output.md.json
deleted file mode 100644
index cefb610d6..000000000
--- a/test/fixture/sync/typedef.output.md.json
+++ /dev/null
@@ -1,215 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "MyType"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "A type definition.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 19,
- "offset": 18
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Properties"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "prop1"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "one property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 13,
- "offset": 12
- },
- "indent": []
- }
- }
- ]
- }
- ]
- },
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "prop2"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "another property",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 17,
- "offset": 16
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/system-import.input.js b/test/fixture/system-import.input.js
deleted file mode 100644
index 95fd643be..000000000
--- a/test/fixture/system-import.input.js
+++ /dev/null
@@ -1,5 +0,0 @@
-/*
- * System.import is a webpack convention
- * https://github.com/documentationjs/documentation/issues/578
- */
-System.import("./simple.input.js").then(() => {});
diff --git a/test/fixture/system-import.output.json b/test/fixture/system-import.output.json
deleted file mode 100644
index ee6fd4cc9..000000000
--- a/test/fixture/system-import.output.json
+++ /dev/null
@@ -1,163 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- }
- }
- },
- "tags": [
- {
- "title": "returns",
- "description": "numberone",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 4,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 5,
- "column": 0
- },
- "end": {
- "line": 8,
- "column": 2
- }
- }
- },
- "errors": [],
- "returns": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- }
- }
- },
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "name": "simple.input",
- "kind": "function",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "simple.input",
- "kind": "function"
- }
- ],
- "namespace": "simple.input"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/system-import.output.md b/test/fixture/system-import.output.md
deleted file mode 100644
index 55ce13e20..000000000
--- a/test/fixture/system-import.output.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-# simple.input
-
-This function returns the number one.
-
-Returns **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** numberone
diff --git a/test/fixture/system-import.output.md.json b/test/fixture/system-import.output.md.json
deleted file mode 100644
index 6f30c7d2d..000000000
--- a/test/fixture/system-import.output.md.json
+++ /dev/null
@@ -1,118 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "simple.input"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "This function returns the number one.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 38,
- "offset": 37
- },
- "indent": []
- }
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "numberone",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 10,
- "offset": 9
- },
- "indent": []
- }
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/this-class.input.js b/test/fixture/this-class.input.js
deleted file mode 100644
index b55ddb699..000000000
--- a/test/fixture/this-class.input.js
+++ /dev/null
@@ -1,13 +0,0 @@
-/** @module bookshelf */
-
-/** @class */
-var Book = function(title) {
- /** The title of the book. */
- this.title = title;
-}
-
-/** @class */
-this.BookShelf = function(title) {
- /** The title of the bookshelf. */
- this.title = title;
-}
diff --git a/test/fixture/this-class.output.json b/test/fixture/this-class.output.json
deleted file mode 100644
index e6c5bf031..000000000
--- a/test/fixture/this-class.output.json
+++ /dev/null
@@ -1,361 +0,0 @@
-[
- {
- "description": "",
- "tags": [
- {
- "title": "module",
- "description": null,
- "lineNumber": 0,
- "type": null,
- "name": "bookshelf"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 1,
- "column": 24
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 1
- }
- }
- },
- "errors": [],
- "kind": "module",
- "name": "bookshelf",
- "params": [
- {
- "title": "param",
- "name": "title",
- "lineNumber": 4
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "bookshelf",
- "kind": "module"
- }
- ],
- "namespace": "bookshelf"
- },
- {
- "description": "",
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 0,
- "name": null
- }
- ],
- "loc": {
- "start": {
- "line": 3,
- "column": 0
- },
- "end": {
- "line": 3,
- "column": 13
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 4,
- "column": 0
- },
- "end": {
- "line": 7,
- "column": 1
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "Book",
- "params": [
- {
- "title": "param",
- "name": "title",
- "lineNumber": 4
- }
- ],
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The title of the book.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 5,
- "column": 4
- },
- "end": {
- "line": 5,
- "column": 33
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 6,
- "column": 3
- },
- "end": {
- "line": 6,
- "column": 22
- }
- }
- },
- "errors": [],
- "name": "title",
- "memberof": "Book",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Book",
- "kind": "class"
- },
- {
- "name": "title",
- "scope": "instance"
- }
- ],
- "namespace": "Book#title"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "Book",
- "kind": "class"
- }
- ],
- "namespace": "Book"
- },
- {
- "description": "",
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 0,
- "name": null
- }
- ],
- "loc": {
- "start": {
- "line": 9,
- "column": 0
- },
- "end": {
- "line": 9,
- "column": 13
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 10,
- "column": 0
- },
- "end": {
- "line": 13,
- "column": 1
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "BookShelf",
- "params": [
- {
- "title": "param",
- "name": "title",
- "lineNumber": 10
- }
- ],
- "members": {
- "instance": [
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The title of the bookshelf.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- }
- }
- },
- "tags": [],
- "loc": {
- "start": {
- "line": 11,
- "column": 4
- },
- "end": {
- "line": 11,
- "column": 38
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 12,
- "column": 3
- },
- "end": {
- "line": 12,
- "column": 22
- }
- }
- },
- "errors": [],
- "name": "title",
- "memberof": "BookShelf",
- "scope": "instance",
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "BookShelf",
- "kind": "class"
- },
- {
- "name": "title",
- "scope": "instance"
- }
- ],
- "namespace": "BookShelf#title"
- }
- ],
- "static": [],
- "events": []
- },
- "path": [
- {
- "name": "BookShelf",
- "kind": "class"
- }
- ],
- "namespace": "BookShelf"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/this-class.output.md b/test/fixture/this-class.output.md
deleted file mode 100644
index 58972fd9b..000000000
--- a/test/fixture/this-class.output.md
+++ /dev/null
@@ -1,27 +0,0 @@
-
-
-# bookshelf
-
-**Parameters**
-
-- `title`
-
-# Book
-
-**Parameters**
-
-- `title`
-
-## title
-
-The title of the book.
-
-# BookShelf
-
-**Parameters**
-
-- `title`
-
-## title
-
-The title of the bookshelf.
diff --git a/test/fixture/this-class.output.md.json b/test/fixture/this-class.output.md.json
deleted file mode 100644
index 0af859a69..000000000
--- a/test/fixture/this-class.output.md.json
+++ /dev/null
@@ -1,240 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "bookshelf"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "title"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Book"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "title"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "title"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The title of the book.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "BookShelf"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "title"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "depth": 2,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "title"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "The title of the bookshelf.",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 28,
- "offset": 27
- },
- "indent": []
- }
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/type_application.output.json b/test/fixture/type_application.output.json
deleted file mode 100644
index 04ec75331..000000000
--- a/test/fixture/type_application.output.json
+++ /dev/null
@@ -1,191 +0,0 @@
-[
- {
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Represents an IPv6 address",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- }
- }
- },
- "tags": [
- {
- "title": "class",
- "description": null,
- "lineNumber": 2,
- "type": null,
- "name": "Address6"
- },
- {
- "title": "param",
- "description": "An IPv6 address string",
- "lineNumber": 3,
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "string"
- }
- ]
- },
- "name": "address"
- }
- ],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 5,
- "column": 3
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 6,
- "column": 0
- }
- }
- },
- "errors": [],
- "kind": "class",
- "name": "Address6",
- "params": [
- {
- "name": "address",
- "lineNumber": 3,
- "description": {
- "type": "root",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "An IPv6 address string",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- }
- }
- },
- "type": {
- "type": "TypeApplication",
- "expression": {
- "type": "NameExpression",
- "name": "Array"
- },
- "applications": [
- {
- "type": "NameExpression",
- "name": "string"
- }
- ]
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "Address6",
- "kind": "class"
- }
- ],
- "namespace": "Address6"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/type_application.output.md b/test/fixture/type_application.output.md
deleted file mode 100644
index d0a37c275..000000000
--- a/test/fixture/type_application.output.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-# Address6
-
-Represents an IPv6 address
-
-**Parameters**
-
-- `address` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)>** An IPv6 address string
diff --git a/test/fixture/type_application.output.md.json b/test/fixture/type_application.output.md.json
deleted file mode 100644
index 278ea5479..000000000
--- a/test/fixture/type_application.output.md.json
+++ /dev/null
@@ -1,161 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "Address6"
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Represents an IPv6 address",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 27,
- "offset": 26
- },
- "indent": []
- }
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "address"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "Array"
- }
- ]
- },
- {
- "type": "text",
- "value": "<"
- },
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "string"
- }
- ]
- },
- {
- "type": "text",
- "value": ">"
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "An IPv6 address string",
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ],
- "position": {
- "start": {
- "line": 1,
- "column": 1,
- "offset": 0
- },
- "end": {
- "line": 1,
- "column": 23,
- "offset": 22
- },
- "indent": []
- }
- }
- ]
- }
- ]
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/fixture/var-function-param-return.input.js b/test/fixture/var-function-param-return.input.js
deleted file mode 100644
index bc3fcce7d..000000000
--- a/test/fixture/var-function-param-return.input.js
+++ /dev/null
@@ -1,2 +0,0 @@
-/** */
-var f = function(x: number): boolean {}
diff --git a/test/fixture/var-function-param-return.output.json b/test/fixture/var-function-param-return.output.json
deleted file mode 100644
index 3594637a0..000000000
--- a/test/fixture/var-function-param-return.output.json
+++ /dev/null
@@ -1,61 +0,0 @@
-[
- {
- "description": "",
- "tags": [],
- "loc": {
- "start": {
- "line": 1,
- "column": 0
- },
- "end": {
- "line": 1,
- "column": 6
- }
- },
- "context": {
- "loc": {
- "start": {
- "line": 2,
- "column": 0
- },
- "end": {
- "line": 2,
- "column": 39
- }
- }
- },
- "errors": [],
- "name": "f",
- "kind": "function",
- "params": [
- {
- "title": "param",
- "name": "x",
- "lineNumber": 2,
- "type": {
- "type": "NameExpression",
- "name": "number"
- }
- }
- ],
- "returns": [
- {
- "type": {
- "type": "NameExpression",
- "name": "boolean"
- }
- }
- ],
- "members": {
- "instance": [],
- "static": []
- },
- "path": [
- {
- "name": "f",
- "kind": "function"
- }
- ],
- "namespace": "f"
- }
-]
\ No newline at end of file
diff --git a/test/fixture/var-function-param-return.output.md b/test/fixture/var-function-param-return.output.md
deleted file mode 100644
index dc2fd69e0..000000000
--- a/test/fixture/var-function-param-return.output.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-# f
-
-**Parameters**
-
-- `x` **[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)**
-
-Returns **[boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)**
diff --git a/test/fixture/var-function-param-return.output.md.json b/test/fixture/var-function-param-return.output.md.json
deleted file mode 100644
index ac9fb9874..000000000
--- a/test/fixture/var-function-param-return.output.md.json
+++ /dev/null
@@ -1,101 +0,0 @@
-{
- "type": "root",
- "children": [
- {
- "type": "html",
- "value": ""
- },
- {
- "depth": 1,
- "type": "heading",
- "children": [
- {
- "type": "text",
- "value": "f"
- }
- ]
- },
- {
- "type": "strong",
- "children": [
- {
- "type": "text",
- "value": "Parameters"
- }
- ]
- },
- {
- "ordered": false,
- "type": "list",
- "children": [
- {
- "type": "listItem",
- "children": [
- {
- "type": "paragraph",
- "children": [
- {
- "type": "inlineCode",
- "value": "x"
- },
- {
- "type": "text",
- "value": " "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "number"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
- }
- ]
- },
- {
- "type": "paragraph",
- "children": [
- {
- "type": "text",
- "value": "Returns "
- },
- {
- "type": "strong",
- "children": [
- {
- "href": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean",
- "type": "link",
- "children": [
- {
- "type": "text",
- "value": "boolean"
- }
- ]
- }
- ]
- },
- {
- "type": "text",
- "value": " "
- }
- ]
- }
- ]
-}
\ No newline at end of file
diff --git a/test/format_type.js b/test/format_type.js
deleted file mode 100644
index 570a627d5..000000000
--- a/test/format_type.js
+++ /dev/null
@@ -1,67 +0,0 @@
-/*eslint max-len: 0 */
-'use strict';
-
-var _formatType = require('../lib/output/util/format_type'),
- createLinkerStack = require('../lib/output/util/linker_stack'),
- remark = require('remark'),
- parse = require('doctrine').parse,
- test = require('tap').test;
-
-function stringify(children) {
- return remark().stringify({
- type: 'paragraph',
- children: children
- });
-}
-
-test('formatType', function (t) {
- var linkerStack = createLinkerStack({});
- var formatType = _formatType.bind(undefined, linkerStack.link);
- [
- ['Foo', 'Foo'],
- ['null', 'null'],
- ['null', 'null'],
- ['*', 'any'],
- ['Array|undefined', '([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \\| [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined))'],
- ['Array', '[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)<[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>'],
- ['number!', '[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)!'],
- ['function(string, boolean)', 'function ([string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String), [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))'],
- ['function(string, boolean): number', 'function ([string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String), [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)): [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)'],
- ['function()', 'function ()'],
- ['function(this:something, string)', 'function (this: something, [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String))'],
- ['function(new:something)', 'function (new: something)'],
- ['{myNum: number, myObject}', '{myNum: [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number), myObject}'],
- ['[string,]', '\\[[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)]'],
- ['number?', '[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?'],
- ['number', '[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)'],
- ['?', '?'],
- ['void', 'void'],
- ['function(a:b)', 'function (a: b)'],
- ['function(a):void', 'function (a): void'],
- ['number=', '[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?'],
- ['...number', '...[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)'],
- ['undefined', '[undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined)']
- ].forEach(function (example) {
- t.deepEqual(stringify(formatType(
- parse('@param {' + example[0] + '} a', { sloppy: true }).tags[0].type)
- ), example[1], example[0]);
- });
-
- t.deepEqual(stringify(formatType(
- parse('@param {number} [a=1]', { sloppy: true }).tags[0].type)
- ), '[number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?', 'default');
-
- t.deepEqual(stringify(_formatType(function (str) {
- return str.toUpperCase();
- }, parse('@param {Foo} a', {
- sloppy: true
- }).tags[0].type)), '[Foo](FOO)', 'with custom linker');
-
- t.deepEqual(stringify(formatType()), 'any', 'empty case');
-
- t.throws(function () {
- formatType({});
- });
-
- t.end();
-});
diff --git a/test/lib/filter_access.js b/test/lib/filter_access.js
deleted file mode 100644
index 55a8f500d..000000000
--- a/test/lib/filter_access.js
+++ /dev/null
@@ -1,82 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- filterAccess = require('../../lib/filter_access');
-
-test('filterAccess ignore', function (t) {
- t.deepEqual(filterAccess(['public', 'protected', 'undefined'], [{
- access: 'public',
- ignore: true
- }]), []);
- t.end();
-});
-
-test('filterAccess public, protected, undefined, no private', function (t) {
- t.deepEqual(filterAccess(['public', 'protected', 'undefined'], [{
- access: 'public'
- }, {
- access: 'protected'
- }, {
- foo: 2
- }, {
- access: 'private'
- }]), [{
- access: 'public'
- }, {
- access: 'protected'
- }, {
- foo: 2
- }]);
- t.end();
-});
-
-test('filterAccess explicit public', function (t) {
- t.deepEqual(filterAccess(['public'], [
- { access: 'public' },
- { access: 'protected' },
- { foo: 2 },
- { access: 'private' }]),
- [{
- access: 'public'
- }]);
- t.end();
-});
-
-test('filterAccess override', function (t) {
- t.deepEqual(filterAccess(['private'], [{
- access: 'private'
- }]), [{
- access: 'private'
- }]);
- t.end();
-});
-
-test('filterAccess nesting', function (t) {
- t.deepEqual(filterAccess(['public', 'protected', 'undefined'], [{
- access: 'public',
- members: {
- static: [{
- access: 'public'
- }, {
- access: 'private'
- }]
- }
- }, {
- access: 'private',
- members: {
- static: [{
- access: 'public'
- }, {
- access: 'private'
- }]
- }
- }]), [{
- access: 'public',
- members: {
- static: [{
- access: 'public'
- }]
- }
- }]);
- t.end();
-});
diff --git a/test/lib/flow_doctrine.js b/test/lib/flow_doctrine.js
deleted file mode 100644
index 67ce55eaa..000000000
--- a/test/lib/flow_doctrine.js
+++ /dev/null
@@ -1,234 +0,0 @@
-'use strict';
-
-var flowDoctrine = require('../../lib/flow_doctrine.js'),
- parse = require('../../lib/parsers/javascript'),
- FLOW_TYPES = require('babel-types').FLOW_TYPES,
- test = require('tap').test;
-
-function toComment(fn, filename) {
- return parse({
- file: filename,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- })[0];
-}
-
-
-
-test('flowDoctrine', function (t) {
-
- var types = FLOW_TYPES.filter(function (type) {
- return type.match(/\wTypeAnnotation$/);
- });
-
- function toDoctrineType(flowType) {
- var annotation = toComment(
- '/** add */function add(a: ' + flowType + ' ) { }'
- ).context.ast.node.params[0].typeAnnotation.typeAnnotation;
- if (types.indexOf(annotation.type) !== -1) {
- types.splice(types.indexOf(annotation.type), 1);
- }
- return flowDoctrine(annotation);
- }
-
- t.deepEqual(toDoctrineType('number'),
- {
- type: 'NameExpression',
- name: 'number'
- }, 'number');
-
- t.deepEqual(toDoctrineType('string'),
- {
- type: 'NameExpression',
- name: 'string'
- }, 'string');
-
- t.deepEqual(toDoctrineType('any'),
- {
- type: 'AllLiteral'
- }, 'all');
-
- t.deepEqual(toDoctrineType('(y:Foo) => Bar'),
- {
- type: 'FunctionType',
- params: [{
- type: 'ParameterType',
- name: 'y',
- expression: {
- type: 'NameExpression',
- name: 'Foo'
- }
- }],
- result: {
- type: 'NameExpression',
- name: 'Bar'
- }
- }, 'function type');
-
- t.deepEqual(toDoctrineType('?number'),
- {
- type: 'NullableType',
- expression: {
- type: 'NameExpression',
- name: 'number'
- }
- }, 'nullable');
-
- t.deepEqual(toDoctrineType('number | string'),
- {
- type: 'UnionType',
- elements: [
- {
- type: 'NameExpression',
- name: 'number'
- },
- {
- type: 'NameExpression',
- name: 'string'
- }
- ]
- }, 'union');
-
- t.deepEqual(toDoctrineType('Object'),
- {
- type: 'NameExpression',
- name: 'Object'
- }, 'object');
-
- t.deepEqual(toDoctrineType('{ a: 1 }'),
- {
- type: 'RecordType',
- fields: [{
- type: 'FieldType',
- key: 'a',
- value: {
- type: 'NumericLiteralType',
- value: 1
- }
- }]
- }, 'object with properties');
-
- t.deepEqual(toDoctrineType('mixed'),
- {
- type: 'AllLiteral'
- }, 'alias mixed to any for now');
-
- t.deepEqual(toDoctrineType('Array'),
- {
- type: 'NameExpression',
- name: 'Array'
- }, 'array');
-
- t.deepEqual(toDoctrineType('Array'),
- {
- type: 'TypeApplication',
- expression: {
- type: 'NameExpression',
- name: 'Array'
- },
- applications: [{
- type: 'NameExpression',
- name: 'number'
- }]
- }, 'Array');
-
- t.deepEqual(toDoctrineType('number[]'),
- {
- type: 'TypeApplication',
- expression: {
- type: 'NameExpression',
- name: 'Array'
- },
- applications: [{
- type: 'NameExpression',
- name: 'number'
- }]
- }, 'number[]');
-
- t.deepEqual(toDoctrineType('[]'),
- {
- type: 'ArrayType',
- elements: []
- }, '[]');
-
- t.deepEqual(toDoctrineType('[number]'),
- {
- type: 'ArrayType',
- elements: [
- {
- type: 'NameExpression',
- name: 'number'
- }
- ]
- }, '[number]');
-
- t.deepEqual(toDoctrineType('[string, boolean]'),
- {
- type: 'ArrayType',
- elements: [
- {
- type: 'NameExpression',
- name: 'string'
- },
- {
- type: 'NameExpression',
- name: 'boolean'
- }
- ]
- }, '[string, boolean]');
-
- t.deepEqual(toDoctrineType('boolean'),
- {
- type: 'NameExpression',
- name: 'boolean'
- }, 'boolean');
-
- t.deepEqual(toDoctrineType('undefined'),
- {
- type: 'NameExpression',
- name: 'undefined'
- }, 'undefined');
-
- t.deepEqual(toDoctrineType('"value"'),
- {
- type: 'StringLiteralType',
- value: 'value'
- }, 'StringLiteralType');
-
- t.deepEqual(toDoctrineType('1'),
- {
- type: 'NumericLiteralType',
- value: '1'
- }, 'NumericLiteralType');
-
- t.deepEqual(toDoctrineType('true'),
- {
- type: 'BooleanLiteralType',
- value: true
- }, 'BooleanLiteralType');
-
- t.deepEqual(toDoctrineType('false'),
- {
- type: 'BooleanLiteralType',
- value: false
- }, 'BooleanLiteralType');
-
- t.deepEqual(toDoctrineType('null'),
- {
- type: 'NullLiteral',
- }, 'NullLiteral');
-
- t.deepEqual(toDoctrineType('void'),
- {
- type: 'VoidLiteral',
- }, 'VoidLiteral');
-
- // TODO: remove all these types
- t.deepEqual(types, [
- 'IntersectionTypeAnnotation',
- 'EmptyTypeAnnotation',
- 'ThisTypeAnnotation',
- 'TypeofTypeAnnotation'
- ], 'Type coverage');
-
- t.end();
-});
diff --git a/test/lib/git/find_git.js b/test/lib/git/find_git.js
deleted file mode 100644
index 79f6d8cf5..000000000
--- a/test/lib/git/find_git.js
+++ /dev/null
@@ -1,21 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- mock = require('mock-fs'),
- mockRepo = require('./mock_repo'),
- findGit = require('../../../lib/git/find_git');
-
-test('findGit', function (t) {
-
- mock(mockRepo.master);
-
- t.equal(
- findGit(
- '/my/repository/path/index.js'),
- '/my/repository/path/.git', 'finds git path');
-
- mock.restore();
-
- t.end();
-});
-
diff --git a/test/lib/git/mock_repo.js b/test/lib/git/mock_repo.js
deleted file mode 100644
index a4b3d3fe4..000000000
--- a/test/lib/git/mock_repo.js
+++ /dev/null
@@ -1,67 +0,0 @@
-module.exports = {
- master: {
- '/my': {
- repository: {
- path: {
- '.git': {
- 'HEAD': 'ref: refs/heads/master',
- 'config': '[remote "origin"]\n' +
- 'url = git@github.com:foo/bar.git\n' +
- 'fetch = +refs/heads/*:refs/remotes/origin/*',
- refs: {
- heads: {
- master: 'this_is_the_sha'
- }
- }
- },
- 'index.js': 'module.exports = 42;'
- }
- }
- }
- },
- detached: {
- '/my': {
- repository: {
- path: {
- '.git': {
- 'HEAD': 'e4cb2ffe677571d0503e659e4e64e01f45639c62',
- 'config': '[remote "origin"]\n' +
- 'url = git@github.com:foo/bar.git\n' +
- 'fetch = +refs/heads/*:refs/remotes/origin/*'
- },
- 'index.js': 'module.exports = 42;'
- }
- }
- }
- },
- malformed: {
- '/my': {
- repository: {
- path: {
- '.git': {},
- 'index.js': 'module.exports = 42;'
- }
- }
- }
- },
- enterprise: {
- '/my': {
- repository: {
- path: {
- '.git': {
- 'HEAD': 'ref: refs/heads/master',
- 'config': '[remote "origin"]\n' +
- 'url = git@github.enterprise.com:foo/bar.git\n' +
- 'fetch = +refs/heads/*:refs/remotes/origin/*',
- refs: {
- heads: {
- master: 'this_is_the_sha'
- }
- }
- },
- 'index.js': 'module.exports = 42;'
- }
- }
- }
- }
-};
diff --git a/test/lib/git/url_prefix.js b/test/lib/git/url_prefix.js
deleted file mode 100644
index 921efc198..000000000
--- a/test/lib/git/url_prefix.js
+++ /dev/null
@@ -1,41 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- mock = require('mock-fs'),
- mockRepo = require('./mock_repo'),
- getGithubURLPrefix = require('../../../lib/git/url_prefix'),
- parsePackedRefs = getGithubURLPrefix.parsePackedRefs;
-
-test('getGithubURLPrefix', function (t) {
-
- mock(mockRepo.master);
-
- t.equal(
- getGithubURLPrefix(
- '/my/repository/path/'),
- 'https://github.com/foo/bar/blob/this_is_the_sha/',
- 'finds git path on master branch');
-
- mock.restore();
-
- mock(mockRepo.detached);
-
- t.equal(
- getGithubURLPrefix(
- '/my/repository/path/'),
- 'https://github.com/foo/bar/blob/e4cb2ffe677571d0503e659e4e64e01f45639c62/',
- 'finds git path with a detached head');
-
- mock.restore();
-
- t.end();
-});
-
-test('parsePackedRefs', function (t) {
- var input = '# pack-refs with: peeled fully-peeled\n' +
- '4acd658617928bd17ae7364ef2512630d97c007a refs/heads/babel-6\n' +
- '11826ad98c6c08d00f4af77f64d3e2687e0f7dba refs/remotes/origin/flow-types';
- t.equal(parsePackedRefs(input, 'refs/heads/babel-6'),
- '4acd658617928bd17ae7364ef2512630d97c007a', 'Finds babel 6 ref');
- t.end();
-});
diff --git a/test/lib/github.js b/test/lib/github.js
deleted file mode 100644
index 2d623f695..000000000
--- a/test/lib/github.js
+++ /dev/null
@@ -1,81 +0,0 @@
-'use strict';
-
-/* eslint no-unused-vars: 0 */
-
-var test = require('tap').test,
- mock = require('mock-fs'),
- mockRepo = require('./git/mock_repo'),
- parse = require('../../lib/parsers/javascript'),
- github = require('../../lib/github');
-
-function toComment(fn, filename) {
- return parse({
- file: filename,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- }).map(github);
-}
-
-function evaluate(fn) {
- return toComment(fn, '/my/repository/path/index.js');
-}
-
-test('github', function (t) {
-
- mock(mockRepo.master);
-
- t.equal(evaluate(function () {
- /**
- * get one
- * @returns {number} one
- */
- function getOne() {
- return 1;
- }
- })[0].context.github,
- 'https://github.com/foo/bar/blob/this_is_the_sha/index.js#L6-L8',
- 'gets github url');
-
- mock.restore();
-
- t.end();
-});
-
-test('malformed repository', function (t) {
-
- mock(mockRepo.malformed);
-
- t.equal(evaluate(function () {
- /**
- * get one
- * @returns {number} one
- */
- function getOne() {
- return 1;
- }
- })[0].context.github, undefined, 'does not crash');
-
- mock.restore();
-
- t.end();
-});
-
-test('enterprise repository', function (t) {
-
- mock(mockRepo.enterprise);
-
- t.equal(evaluate(function () {
- /**
- * get one
- * @returns {number} one
- */
- function getOne() {
- return 1;
- }
- })[0].context.github,
- 'https://github.enterprise.com/foo/bar/blob/this_is_the_sha/index.js#L6-L8',
- 'gets github enterprise url');
-
- mock.restore();
-
- t.end();
-});
diff --git a/test/lib/hierarchy.js b/test/lib/hierarchy.js
deleted file mode 100644
index 779d08c1a..000000000
--- a/test/lib/hierarchy.js
+++ /dev/null
@@ -1,187 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../lib/parsers/javascript'),
- hierarchy = require('../../lib/hierarchy');
-
-function toComments(fn, filename) {
- return parse({
- file: filename || 'test.js',
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- });
-}
-
-function evaluate(fn, callback) {
- return hierarchy(toComments(fn, callback));
-}
-
-function map(arr, prop) {
- return arr.map(function (item) {
- return item[prop];
- });
-}
-
-test('hierarchy', function (t) {
- var comments = evaluate(function () {
- /**
- * @name Class
- * @class
- */
-
- /**
- * @name getFoo
- * @memberof Class
- * @instance
- */
-
- /**
- * @name isClass
- * @memberof Class
- * @static
- */
-
- /**
- * @name MAGIC_NUMBER
- * @memberof Class
- */
-
- /**
- * @name event
- * @memberof Class
- * @kind event
- * @instance
- */
- });
-
- t.deepEqual(map(comments, 'name'), ['Class']);
-
- var classMembers = comments[0].members;
-
- t.deepEqual(map(classMembers.static, 'name'), ['isClass', 'MAGIC_NUMBER']);
- t.deepEqual(map(classMembers.instance, 'name'), ['getFoo']);
-
- t.deepEqual(map(classMembers.static[0].path, 'name'), ['Class', 'isClass']);
- t.deepEqual(map(classMembers.instance[0].path, 'name'), ['Class', 'getFoo']);
- t.deepEqual(map(classMembers.events[0].path, 'name'), ['Class', 'event']);
-
- t.end();
-});
-
-test('hierarchy - nesting', function (t) {
- var comments = evaluate(function () {
- /**
- * @name Parent
- * @class
- */
-
- /**
- * @name enum
- * @memberof Parent
- */
-
- /**
- * @name Parent
- * @memberof Parent.enum
- */
-
- /**
- * @name Child
- * @memberof Parent.enum
- */
- });
-
- t.deepEqual(map(comments, 'name'), ['Parent']);
-
- var classMembers = comments[0].members;
- t.deepEqual(map(classMembers.static, 'name'), ['enum']);
-
- var enumMembers = classMembers.static[0].members;
- t.deepEqual(map(enumMembers.static, 'name'), ['Parent', 'Child']);
- t.deepEqual(map(enumMembers.static[0].path, 'name'), ['Parent', 'enum', 'Parent']);
- t.deepEqual(map(enumMembers.static[1].path, 'name'), ['Parent', 'enum', 'Child']);
-
- t.end();
-});
-
-test('hierarchy - multisignature', function (t) {
- var comments = evaluate(function () {
- /**
- * @name Parent
- * @class
- */
-
- /**
- * @name foo
- * @memberof Parent
- * @instance
- */
-
- /**
- * @name foo
- * @memberof Parent
- * @instance
- */
- });
-
- t.deepEqual(map(comments[0].members.instance, 'name'), ['foo', 'foo']);
- t.end();
-});
-
-test('hierarchy - missing memberof', function (t) {
- var test = evaluate(function () {
- /**
- * @name test
- * @memberof DoesNotExist
- */
- })[0];
-
- t.deepEqual(test.errors, [{
- message: '@memberof reference to DoesNotExist not found',
- commentLineNumber: 2
- }], 'correct error message');
- t.end();
-});
-
-test('hierarchy - anonymous', function (t) {
- var result = evaluate(function () {
- /** Test */
- })[0];
-
- t.deepEqual(result.errors, [{
- message: 'could not determine @name for hierarchy'
- }]);
- t.end();
-});
-
-test('hierarchy - object prototype member names', function (t) {
- var comments = evaluate(function () {
- /**
- * @name should
- * @function
- */
-
- /**
- * @name Assertion
- * @class
- * @memberof should
- */
-
- /**
- * @name hasOwnProperty
- * @memberof should.Assertion
- * @instance
- * @function
- **/
-
- /**
- * @name otherMethod
- * @memberof should.Assertion
- * @instance
- * @function
- **/
- });
-
- t.deepEqual(map(comments[0].members.static[0].members.instance, 'name'), [ 'hasOwnProperty', 'otherMethod' ]);
-
- t.end();
-});
diff --git a/test/lib/infer/access.js b/test/lib/infer/access.js
deleted file mode 100644
index 76454a1c3..000000000
--- a/test/lib/infer/access.js
+++ /dev/null
@@ -1,40 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../../lib/parsers/javascript'),
- inferName = require('../../../lib/infer/name')(),
- inferAccess = require('../../../lib/infer/access');
-
-function toComment(fn) {
- return parse({
- source: '(' + fn.toString() + ')'
- })[0];
-}
-
-function evaluate(fn, re) {
- return inferAccess(re)(inferName(toComment(fn)));
-}
-
-test('inferAccess', function (t) {
- t.equal(evaluate(function () {
- /** Test */
- function _name() {}
- }, '^_').access, 'private');
-
- t.equal(evaluate(function () {
- /** @private */
- function name() {}
- }, '^_').access, 'private');
-
- t.equal(evaluate(function () {
- /** @public */
- function _name() {}
- }, '^_').access, 'public');
-
- t.equal(evaluate(function () {
- /** Test */
- function name_() {}
- }, '_$').access, 'private');
-
- t.end();
-});
diff --git a/test/lib/infer/kind.js b/test/lib/infer/kind.js
deleted file mode 100644
index 0231f6cc1..000000000
--- a/test/lib/infer/kind.js
+++ /dev/null
@@ -1,96 +0,0 @@
-'use strict';
-/*eslint-disable no-unused-vars*/
-var test = require('tap').test,
- inferKind = require('../../../lib/infer/kind')(),
- parse = require('../../../lib/parsers/javascript');
-
-function toComment(fn, filename) {
- return parse({
- file: filename,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- })[0];
-}
-
-test('inferKind', function (t) {
- t.equal(inferKind({
- kind: 'class',
- tags: []
- }).kind, 'class', 'explicit');
-
- t.equal(inferKind(toComment(
- '/**' +
- ' * Class' +
- ' */' +
- 'class C {}')).kind, 'class', 'es6 syntax');
-
- t.equal(inferKind(toComment(
- '/**' +
- ' * Exported class' +
- ' */' +
- 'export class C {}')).kind, 'class', 'es6 syntax with export');
-
- t.equal(inferKind(toComment(
- '/**' +
- ' * Export default class' +
- ' */' +
- 'export default class C {}')).kind, 'class', 'es6 syntax with default export');
-
- t.equal(inferKind(toComment(function () {
- /** function */
- function foo() { }
- foo();
- })).kind, 'function', 'inferred function');
-
- t.equal(inferKind(toComment(function () {
- /** function */
- var foo = function () { };
- foo();
- })).kind, 'function', 'inferred var function');
-
- t.equal(inferKind(toComment(
- '/** Exported function */' +
- 'export function foo() {}')).kind, 'function', 'inferred exported function');
-
- t.equal(inferKind(toComment(
- '/** Export default function */' +
- 'export default function foo() {}')).kind, 'function', 'inferred exported function');
-
- t.equal(inferKind(toComment(
- 'class Foo { /** set b */ set b(v) { } }'
- )).kind, 'member', 'member via set');
-
- t.equal(inferKind(toComment(
- 'var foo = { /** thing */ b: function(v) { } }'
- )).kind, 'function', 'function via set');
-
- t.equal(inferKind(toComment(
- 'class Foo { /** get b */ get b() { } }'
- )).kind, 'member', 'member via get');
-
- t.equal(inferKind(toComment(
- 'class Foo { /** b */ b(v) { } }'
- )).kind, 'function', 'normal function as part of class');
-
- t.equal(inferKind(toComment(function () {
- /** class */
- function Foo() { }
- })).kind, 'class', 'class via uppercase');
-
- t.equal(inferKind(toComment(function () {
- /** undefined */
- })).kind, undefined, 'undetectable');
-
- t.equal(inferKind(toComment(
- '/**' +
- ' * This is a constant called foo' +
- ' */' +
- 'const foo = "bar";')).kind, 'constant', 'constant via const');
-
- t.equal(inferKind(toComment(
- '/**' +
- ' * Exported constant' +
- ' */' +
- 'export const foo = "bar";')).kind, 'constant', 'constant via export const');
-
- t.end();
-});
diff --git a/test/lib/infer/membership.js b/test/lib/infer/membership.js
deleted file mode 100644
index 746b54553..000000000
--- a/test/lib/infer/membership.js
+++ /dev/null
@@ -1,479 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../../lib/parsers/javascript'),
- inferMembership = require('../../../lib/infer/membership')();
-
-function toComment(fn, file) {
- return parse({
- file: file,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- });
-}
-
-function pick(obj, props) {
- return props.reduce(function (memo, prop) {
- if (obj[prop] !== undefined) {
- memo[prop] = obj[prop];
- }
- return memo;
- }, {});
-}
-
-function evaluate(fn, file) {
- return toComment(fn, file).map(inferMembership);
-}
-
-function Foo() {}
-function lend() {}
-
-test('inferMembership - explicit', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /**
- * Test
- * @memberof Bar
- * @static
- */
- Foo.bar = 0;
- })[0], ['memberof', 'scope']), {
- memberof: 'Bar',
- scope: 'static'
- }, 'explicit, static');
-
- t.deepEqual(pick(evaluate(function () {
- /**
- * Test
- * @memberof Bar#
- */
- Foo.bar = 0;
- })[0], ['memberof', 'scope']), {
- memberof: 'Bar',
- scope: 'instance'
- }, 'explicit, instance');
-
- t.deepEqual(pick(evaluate(function () {
- /**
- * Test
- * @memberof Bar.prototype
- */
- Foo.bar = 0;
- })[0], ['memberof', 'scope']), {
- memberof: 'Bar',
- scope: 'instance'
- }, 'explicit, prototype');
-
- t.deepEqual(pick(evaluate(function () {
- /** Test */
- Foo.bar = 0;
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'static'
- }, 'implicit');
-
- t.deepEqual(pick(evaluate(function () {
- /** Test */
- Foo.prototype.bar = 0;
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'instance');
-
- t.deepEqual(pick(evaluate(function () {
- /** Test */
- Foo.bar.baz = 0;
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo.bar',
- scope: 'static'
- }, 'compound');
-
- t.deepEqual(pick(evaluate(function () {
- /** Test */
- (0).baz = 0;
- })[0], ['memberof', 'scope']), { }, 'unknown');
-
- t.deepEqual(pick(evaluate(function () {
- Foo.bar = {
- /** Test */
- baz: 0
- };
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo.bar',
- scope: 'static'
- }, 'static object assignment');
-
- t.deepEqual(pick(evaluate(function () {
- Foo.prototype = {
- /** Test */
- bar: 0
- };
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'instance object assignment');
-
- t.deepEqual(pick(evaluate(function () {
- Foo.prototype = {
- /**
- * Test
- */
- bar: function () {}
- };
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'instance object assignment, function');
-
- t.deepEqual(pick(evaluate(function () {
- var Foo = {
- /** Test */
- baz: 0
- };
- return Foo;
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'static'
- }, 'variable object assignment');
-
- t.deepEqual(pick(evaluate(function () {
- var Foo = {
- /** Test */
- baz: function () {}
- };
- return Foo;
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'static'
- }, 'variable object assignment, function');
-
- t.deepEqual(pick(evaluate(function () {
- function Foo() {
- {
- /** */
- this.bar = 0;
- }
- }
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'constructor function declaration assignment');
-
- t.deepEqual(pick(evaluate(function () {
- var Foo = function Bar() {
- {
- /** */
- this.baz = 0;
- }
- };
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'constructor function expression assignment');
-
- t.deepEqual(pick(evaluate(function () {
- class Foo {
- constructor() {
- {
- /** */
- this.bar = 0;
- }
- }
- }
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'constructor assignment');
-
- t.deepEqual(pick(evaluate(function () {
- /** Test */
- module.exports = function () {};
- })[0], ['memberof', 'scope']), {
- memberof: 'module',
- scope: 'static'
- }, 'simple');
-
- t.deepEqual(pick(evaluate(function () {
- lend(/** @lends Foo */{
- /** Test */
- bar: 0
- });
- })[1], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'static'
- }, 'lends, static');
-
- t.deepEqual(pick(evaluate(function () {
- lend(/** @lends Foo */{
- /** Test */
- bar: function () {}
- });
- })[1], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'static'
- }, 'inferMembership - lends, static, function');
-
- t.deepEqual(pick(evaluate(function () {
- lend(/** @lends Foo.prototype */{
- /** Test */
- bar: 0
- });
- })[1], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- });
-
- t.deepEqual(pick(evaluate(function () {
- lend(/** @lends Foo.prototype */{
- /** Test */
- bar: function () {}
- });
- })[1], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- }, 'inferMembership - lends, instance, function');
-
- // t.deepEqual(pick(evaluate(function () {
- // /** Foo */
- // function Foo() {
- // /** Test */
- // function bar() {}
- // return {
- // bar: bar
- // };
- // }
- // })[1], ['memberof', 'scope']), {
- // memberof: 'Foo',
- // scope: 'static'
- // }, 'inferMembership - revealing, static, function');
-
- t.equal(evaluate(function () {
- lend(/** @lends Foo */{});
- /** Test */
- })[1].memberof, undefined, 'inferMembership - lends applies only to following object');
-
- t.equal(evaluate(function () {
- lend(/** @lends Foo */{});
- })[0], undefined, 'inferMembership - drops lends');
-
- t.end();
-});
-
-test('inferMembership - exports', function (t) {
- t.equal(evaluate(function () {
- /** @module mod */
- /** foo */
- exports.foo = 1;
- })[1].memberof, 'mod');
-
- t.equal(evaluate(function () {
- /** @module mod */
- /** foo */
- exports.foo = function () {};
- })[1].memberof, 'mod');
-
- t.equal(evaluate(function () {
- /** @module mod */
- /** bar */
- exports.foo.bar = 1;
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- exports.foo = {
- /** bar */
- bar: 1
- };
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- exports.foo = {
- /** bar */
- bar: function () {}
- };
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- /** bar */
- exports.foo.prototype.bar = function () {};
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- exports.foo.prototype = {
- /** bar */
- bar: function () {}
- };
- })[1].memberof, 'mod.foo');
-
- t.end();
-});
-
-test('inferMembership - module.exports', function (t) {
- t.equal(evaluate(function () {
- /** @module mod */
- /** foo */
- module.exports.foo = 1;
- })[1].memberof, 'mod');
-
- t.equal(evaluate(function () {
- /** @module mod */
- /** foo */
- module.exports.foo = function () {};
- })[1].memberof, 'mod');
-
- t.equal(evaluate(function () {
- /** @module mod */
- /** bar */
- module.exports.foo.bar = 1;
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- module.exports.foo = {
- /** bar */
- bar: 1
- };
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- module.exports.foo = {
- /** bar */
- bar: function () {}
- };
- })[1].memberof, 'mod.foo');
-
- t.equal(evaluate(function () {
- /** @module mod */
- /** bar */
- module.exports.prototype.bar = function () {};
- })[1].memberof, 'mod');
-
- t.equal(evaluate(function () {
- /** @module mod */
- module.exports.prototype = {
- /** bar */
- bar: function () {}
- };
- })[1].memberof, 'mod');
-
- t.equal(evaluate(function () {
- /**
- * @module mod
- * @name exports
- */
- module.exports = 1;
- })[0].memberof, undefined);
-
- t.equal(evaluate(function () {
- /**
- * @module mod
- * @name exports
- */
- module.exports = function () {};
- })[0].memberof, undefined);
-
- t.equal(evaluate(function () {
- /** @module mod */
- module.exports = {
- /** foo */
- foo: 1
- };
- })[1].memberof, 'mod');
-
- t.end();
-});
-
-test('inferMembership - not module exports', function (t) {
- var result = evaluate(function () {
- /**
- * @module mod
- */
- /** Test */
- global.module.exports.foo = 1;
- }, '/path/mod.js');
-
- t.equal(result.length, 2);
- t.notEqual(result[0].memberof, 'mod');
- t.end();
-});
-
-test('inferMembership - anonymous @module', function (t) {
- var result = evaluate(function () {
- /**
- * @module
- */
- /** Test */
- exports.foo = 1;
- }, '/path/mod.js');
-
- t.equal(result.length, 2);
- t.equal(result[1].memberof, 'mod');
- t.end();
-});
-
-test('inferMembership - no @module', function (t) {
- var result = evaluate(function () {
- /** Test */
- exports.foo = 1;
- }, '/path/mod.js');
-
- t.equal(result.length, 1);
- t.equal(result[0].memberof, 'mod');
- t.end();
-});
-
-test('inferMembership - https://github.com/documentationjs/documentation/issues/378', function (t) {
- t.deepEqual(pick(evaluate(function () {
- Foo.prototype = {
- /** Test */
- bar: function () {
- lend();
- lend();
- }
- };
- })[0], ['memberof', 'scope']), {
- memberof: 'Foo',
- scope: 'instance'
- });
-
- t.end();
-});
-
-test('inferMembership - export', function (t) {
- t.deepEqual(pick(evaluate(
- 'export default class {' +
- ' /** */' +
- ' method() {}' +
- '}',
- 'test-file'
- )[0], ['memberof', 'scope']), {
- memberof: 'test-file',
- scope: 'instance'
- });
-
- t.deepEqual(pick(evaluate(
- 'export default class C {' +
- ' /** */' +
- ' method() {}' +
- '}',
- 'test-file'
- )[0], ['memberof', 'scope']), {
- memberof: 'C',
- scope: 'instance'
- });
-
- t.deepEqual(pick(evaluate(
- 'export class C {' +
- ' /** */' +
- ' method() {}' +
- '}',
- 'test-file'
- )[0], ['memberof', 'scope']), {
- memberof: 'C',
- scope: 'instance'
- });
-
- t.end();
-});
diff --git a/test/lib/infer/name.js b/test/lib/infer/name.js
deleted file mode 100644
index c155ba781..000000000
--- a/test/lib/infer/name.js
+++ /dev/null
@@ -1,145 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../../lib/parsers/javascript'),
- inferName = require('../../../lib/infer/name')();
-
-function toComment(fn, file) {
- return parse({
- file: file,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- })[0];
-}
-
-function evaluate(fn, file) {
- return inferName(toComment(fn, file));
-}
-
-test('inferName', function (t) {
- t.equal(evaluate(function () {
- // ExpressionStatement (comment attached here)
- // AssignmentExpression
- // MemberExpression
- // Identifier
- /** Test */
- exports.name = test;
- }).name, 'name', 'expression statement');
-
- t.equal(evaluate(function () {
- // ExpressionStatement
- // AssignmentExpression
- // MemberExpression (comment attached here)
- // FunctionExpression
- /** Test */
- exports.name = function () {};
- }).name, 'name', 'expression statement, function');
-
- t.equal(evaluate(function () {
- exports = {
- // Property (comment attached here)
- // Identifier
- // FunctionExpression
- /** Test */
- name: test
- };
- }).name, 'name', 'property');
-
- t.equal(evaluate(function () {
- exports = {
- // Property
- // Identifier (comment attached here)
- // FunctionExpression
- /** Test */
- name: function () {}
- };
- }).name, 'name', 'property, function');
-
- t.equal(evaluate(function () {
- /** Test */
- function name() {}
- }).name, 'name', 'function declaration');
-
- t.equal(evaluate(function () {
- /** Test */
- var name = function () {};
- }).name, 'name', 'anonymous function expression');
-
- t.equal(evaluate(function () {
- /** Test */
- var name = function name2() {};
- }).name, 'name', 'named function expression');
-
- t.equal(evaluate(function () {
- /** @name explicitName */
- function implicitName() {}
- }).name, 'explicitName', 'explicit name');
-
- t.equal(evaluate(function () {
- /** @alias explicitAlias */
- function implicitName() {}
- }).name, 'explicitAlias', 'explicit alias');
-
- t.equal(evaluate(function () {
- /** @class ExplicitClass */
- function ImplicitClass() {}
- }).name, 'ExplicitClass', 'explicit class');
-
- t.equal(evaluate(function () {
- /** @class */
- function ImplicitClass() {}
- }).name, 'ImplicitClass', 'anonymous class');
-
- t.equal(evaluate(function () {
- /** @event explicitEvent */
- function implicitName() {}
- }).name, 'explicitEvent', 'explicitEvent');
-
- t.equal(evaluate(function () {
- /** @typedef {Object} ExplicitTypedef */
- function implicitName() {}
- }).name, 'ExplicitTypedef', 'ExplicitTypedef');
-
- t.equal(evaluate(function () {
- /** @callback explicitCallback */
- function implicitName() {}
- }).name, 'explicitCallback', 'explicitCallback');
-
- t.equal(evaluate(function () {
- /** @module explicitModule */
- function implicitName() {}
- }).name, 'explicitModule');
-
- t.equal(evaluate(function () {
- /** @module {Function} explicitModule */
- function implicitName() {}
- }).name, 'explicitModule');
-
- t.equal(evaluate(function () {
- /** @module */
- function implicitName() {}
- }, '/path/inferred-from-file.js').name, 'inferred-from-file');
-
- t.equal(evaluate(function () {
- /** @module */
- }, '/path/inferred-from-file.js').name, 'inferred-from-file');
-
- t.equal(evaluate('/** Test */ export function exported() {}').name, 'exported');
-
- t.equal(evaluate('/** Test */ export default function() {}',
- '/path/inferred-from-file.js').name, 'inferred-from-file');
-
- t.equal(evaluate('/** Test */ export default function exported() {}',
- '/path/inferred-from-file.js').name, 'exported');
-
- t.equal(evaluate('/** Test */ export var life = 42;').name, 'life');
-
- t.equal(evaluate('/** Test */ export class Wizard {}').name, 'Wizard');
-
- t.equal(evaluate('/** Test */ export default class Warlock {}',
- '/path/inferred-from-file.js').name, 'Warlock');
-
- t.equal(evaluate('/** Test */ export default class {}',
- '/path/inferred-from-file.js').name, 'inferred-from-file');
-
- t.end();
-});
diff --git a/test/lib/infer/params.js b/test/lib/infer/params.js
deleted file mode 100644
index b318918c4..000000000
--- a/test/lib/infer/params.js
+++ /dev/null
@@ -1,47 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../../lib/parsers/javascript'),
- inferParams = require('../../../lib/infer/params')();
-
-function toComment(fn, file) {
- return parse({
- file: file,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- })[0];
-}
-
-function evaluate(fn, file) {
- return inferParams(toComment(fn, file));
-}
-
-test('inferParams', function (t) {
- t.deepEqual(evaluate(function () {
- /** Test */
- function f(x) {}
- }).params, [{lineNumber: 3, name: 'x', title: 'param'}]);
-
- t.deepEqual(evaluate(function () {
- /** Test */
- var f = function (x) {};
- }).params, [{lineNumber: 3, name: 'x', title: 'param'}]);
-
- t.deepEqual(evaluate('/** Test */ var f = (x) => {}').params,
- [{lineNumber: 1, name: 'x', title: 'param'}]);
-
- t.deepEqual(evaluate(function () {
- var x = 1,
- g = function (y) {},
- /** Test */
- f = function (x) {};
- }).params, [{lineNumber: 5, name: 'x', title: 'param'}]);
-
-
- t.deepEqual(evaluate('/** Test */ export function f(x) {}').params,
- [{lineNumber: 1, name: 'x', title: 'param'}]);
-
- t.deepEqual(evaluate('/** Test */ export default function f(x) {}').params,
- [{lineNumber: 1, name: 'x', title: 'param'}]);
-
- t.end();
-});
diff --git a/test/lib/infer/type.js b/test/lib/infer/type.js
deleted file mode 100644
index 6777d79dc..000000000
--- a/test/lib/infer/type.js
+++ /dev/null
@@ -1,135 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../../lib/parsers/javascript'),
- inferKind = require('../../../lib/infer/kind')(),
- inferType = require('../../../lib/infer/type')();
-
-function toComment(code) {
- return parse({
- source: code
- })[0];
-}
-
-function evaluate(code) {
- return inferType(inferKind(toComment(code)));
-}
-
-test('inferType', function (t) {
- t.deepEqual(evaluate(
- '/** @typedef {T} V */'
- ).type, {
- name: 'T',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'type V = T'
- ).type, {
- name: 'T',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** @typedef {Array} V */'
- ).type, {
- applications: [
- {
- name: 'T',
- type: 'NameExpression'
- }
- ],
- expression: {
- name: 'Array',
- type: 'NameExpression'
- },
- type: 'TypeApplication'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'type V = Array'
- ).type, {
- applications: [
- {
- name: 'T',
- type: 'NameExpression'
- }
- ],
- expression: {
- name: 'Array',
- type: 'NameExpression'
- },
- type: 'TypeApplication'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'var x: number'
- ).type, {
- name: 'number',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'let x: number'
- ).type, {
- name: 'number',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'const x: number = 42;'
- ).type, {
- name: 'number',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- 'let x,' +
- '/** */' +
- 'y: number'
- ).type, {
- name: 'number',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- 'class C {' +
- '/** */' +
- 'x: number;' +
- '}'
- ).type, {
- name: 'number',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'const x = 42;'
- ).type, {
- name: 'number',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'const x = "abc";'
- ).type, {
- name: 'string',
- type: 'NameExpression'
- });
-
- t.deepEqual(evaluate(
- '/** */' +
- 'const x = true;'
- ).type, {
- name: 'boolean',
- type: 'NameExpression'
- });
-
- t.end();
-});
diff --git a/test/lib/input/shallow.js b/test/lib/input/shallow.js
deleted file mode 100644
index 6eb9fc491..000000000
--- a/test/lib/input/shallow.js
+++ /dev/null
@@ -1,60 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- path = require('path'),
- shallow = require('../../../lib/input/shallow');
-
-test('shallow deps', function (t) {
- shallow([path.resolve(path.join(__dirname, '../../fixture/es6.input.js'))], {}, function (err, deps) {
- t.ifError(err);
- t.equal(deps.length, 1);
- t.ok(deps[0], 'has path');
- t.end();
- });
-});
-
-test('shallow deps multi', function (t) {
- shallow([
- path.resolve(path.join(__dirname, '../../fixture/es6.input.js')),
- path.resolve(path.join(__dirname, '../../fixture/es6.output.json'))
- ], {}, function (err, deps) {
- t.ifError(err);
- t.equal(deps.length, 2);
- t.ok(deps[0], 'has path');
- t.end();
- });
-});
-
-test('shallow deps directory', function (t) {
- shallow([
- path.resolve(path.join(__dirname, '../../fixture/html'))
- ], {}, function (err, deps) {
- t.ifError(err);
- t.equal(deps.length, 1);
- t.ok(deps[0].match(/input.js/), 'is the input file');
- t.end();
- });
-});
-
-test('shallow deps not found', function (t) {
- t.throws(function () {
- shallow([
- 'not-found-file'
- ], {});
- }, 'not found');
- t.end();
-});
-
-test('shallow deps literal', function (t) {
- var obj = {
- file: 'foo.js',
- source: '//bar'
- };
- shallow([
- obj
- ], {}, function (err, deps) {
- t.ifError(err);
- t.equal(deps[0], obj);
- t.end();
- });
-});
diff --git a/test/lib/lint.js b/test/lib/lint.js
deleted file mode 100644
index 8b769ade5..000000000
--- a/test/lib/lint.js
+++ /dev/null
@@ -1,69 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../lib/parsers/javascript'),
- lintComments = require('../../lib/lint').lintComments,
- formatLint = require('../../lib/lint').formatLint;
-
-function toComment(fn, filename) {
- return parse({
- file: filename,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- })[0];
-}
-
-function evaluate(fn) {
- return lintComments(toComment(fn, 'input.js'));
-}
-
-test('lintComments', function (t) {
- t.deepEqual(evaluate(function () {
- /**
- * @param {foo
- */
- }).errors, [
- { message: 'Braces are not balanced' },
- { message: 'Missing or invalid tag name' }
- ], 'doctrine error');
-
- t.deepEqual(evaluate(function () {
- /**
- * @param {String} foo
- * @param {array} bar
- */
- }).errors, [
- { commentLineNumber: 1, message: 'type String found, string is standard' },
- { commentLineNumber: 2, message: 'type array found, Array is standard' }
- ], 'non-canonical');
-
- t.deepEqual(evaluate(function () {
- /**
- * @param {string} foo
- */
- }).errors, [], 'no errors');
-
- t.end();
-});
-
-test('formatLint', function (t) {
- var comment = evaluate(function () {
- // 2
- // 3
- /** 4
- * @param {String} foo
- * @param {array} bar
- * @param {foo
- */
- });
-
- var formatted = formatLint([comment]);
-
- t.contains(formatted, 'input.js');
- t.contains(formatted, /4:1[^\n]+Braces are not balanced/);
- t.contains(formatted, /4:1[^\n]+Missing or invalid tag name/);
- t.contains(formatted, /5:1[^\n]+type String found, string is standard/);
- t.contains(formatted, /6:1[^\n]+type array found, Array is standard/);
- t.contains(formatted, '4 warnings');
-
- t.end();
-});
diff --git a/test/lib/load_config.js b/test/lib/load_config.js
deleted file mode 100644
index 64ee5d48f..000000000
--- a/test/lib/load_config.js
+++ /dev/null
@@ -1,39 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- path = require('path'),
- loadConfig = require('../../lib/load_config');
-
-test('loadConfig', function (t) {
-
- t.throws(function () {
- loadConfig('DOES-NOT-EXIST');
- });
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config.json')),
- { foo: 'bar' });
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config_comments.json')),
- { foo: 'bar' }, 'config with comments');
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config.yaml')),
- { foo: 'bar' }, 'config.yaml');
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config.yml')),
- { foo: 'bar' }, 'config.yml');
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config')),
- { foo: 'bar' }, 'config in yaml without extension');
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config_links.yml')),
- { foo: 'hello [link](https://github.com/my/link) world' }, 'config with markdown link');
-
- t.deepEqual(loadConfig(path.join(__dirname, '../config_fixture/config_file.yml')),{
- toc: [{
- name: 'snowflake',
- file: path.join(__dirname, '../fixture/snowflake.md')
- }]
- }, 'config with file reference');
-
- t.end();
-});
diff --git a/test/lib/nest.js b/test/lib/nest.js
deleted file mode 100644
index 5b4aa286b..000000000
--- a/test/lib/nest.js
+++ /dev/null
@@ -1,90 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../lib/parsers/javascript'),
- nest = require('../../lib/nest');
-
-function toComment(fn, filename) {
- return parse({
- file: filename,
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- }).map(nest);
-}
-
-test('nest params - no params', function (t) {
- t.equal(toComment(function () {
- /** @name foo */
- })[0].params, undefined, 'no params');
- t.end();
-});
-
-test('nest params - no nesting', function (t) {
- var result = toComment(function () {
- /** @param {Object} foo */
- });
- t.equal(result[0].params.length, 1);
- t.equal(result[0].params[0].name, 'foo');
- t.equal(result[0].params[0].properties, undefined);
- t.end();
-});
-
-test('nest params - basic', function (t) {
- var result = toComment(function () {
- /**
- * @param {Object} foo
- * @param {string} foo.bar
- * @param {string} foo.baz
- */
- });
- t.equal(result[0].params.length, 1);
- t.equal(result[0].params[0].name, 'foo');
- t.equal(result[0].params[0].properties.length, 2);
- t.equal(result[0].params[0].properties[0].name, 'foo.bar');
- t.equal(result[0].params[0].properties[1].name, 'foo.baz');
- t.end();
-});
-
-test('nest properties - basic', function (t) {
- var result = toComment(function () {
- /**
- * @property {Object} foo
- * @property {string} foo.bar
- * @property {string} foo.baz
- */
- });
- t.equal(result[0].properties.length, 1);
- t.equal(result[0].properties[0].name, 'foo');
- t.equal(result[0].properties[0].properties.length, 2);
- t.equal(result[0].properties[0].properties[0].name, 'foo.bar');
- t.equal(result[0].properties[0].properties[1].name, 'foo.baz');
- t.end();
-});
-
-test('nest params - array', function (t) {
- var result = toComment(function () {
- /**
- * @param {Object[]} employees - The employees who are responsible for the project.
- * @param {string} employees[].name - The name of an employee.
- * @param {string} employees[].department - The employee's department.
- */
- });
- t.equal(result[0].params.length, 1);
- t.equal(result[0].params[0].name, 'employees');
- t.equal(result[0].params[0].properties.length, 2);
- t.equal(result[0].params[0].properties[0].name, 'employees[].name');
- t.equal(result[0].params[0].properties[1].name, 'employees[].department');
- t.end();
-});
-
-test('nest params - missing parent', function (t) {
- var result = toComment(function () {
- /** @param {string} foo.bar */
- });
- t.equal(result[0].params.length, 1);
- t.deepEqual(result[0].errors[0], {
- message: '@param foo.bar\'s parent foo not found',
- commentLineNumber: 0
- }, 'correct error message');
- t.equal(result[0].params[0].name, 'foo.bar');
- t.end();
-});
diff --git a/test/lib/output/util/formatters.js b/test/lib/output/util/formatters.js
deleted file mode 100644
index 4a95b72a1..000000000
--- a/test/lib/output/util/formatters.js
+++ /dev/null
@@ -1,38 +0,0 @@
-var test = require('tap').test;
-var formatters = require('../../../../lib/output/util/formatters')(getHref);
-
-test('formatters.parameters -- long form', function (t) {
- t.deepEqual(formatters.parameters({}), '()');
- t.deepEqual(formatters.parameters({ params: [] }), '()');
- t.deepEqual(formatters.parameters({ params: [{ name: 'foo' }] }), '(foo: any)');
- t.deepEqual(formatters.parameters({ params: [{ name: 'foo', type: { type: 'OptionalType' } }] }), '(foo: any?)');
- t.done();
-});
-
-test('formatters.parameters -- short form', function (t) {
- t.deepEqual(formatters.parameters({}, true), '()');
- t.deepEqual(formatters.parameters({ params: [] }, true), '()');
- t.deepEqual(formatters.parameters({ params: [{ name: 'foo' }] }, true), '(foo)');
- t.deepEqual(formatters.parameters({
- params: [{ name: 'foo', type: { type: 'OptionalType' } }]
- }, true), '(foo?)');
- t.deepEqual(formatters.parameters({
- params: [{
- title: 'param',
- description: 'param',
- type: {
- type: 'OptionalType',
- expression: {
- type: 'NameExpression',
- name: 'number'
- }},
- name: 'bar',
- default: '1'
- }]
- }, true), '(bar = 1)');
- t.done();
-});
-
-function getHref(x) {
- return x;
-}
diff --git a/test/lib/parse.js b/test/lib/parse.js
deleted file mode 100644
index 46c50bdbf..000000000
--- a/test/lib/parse.js
+++ /dev/null
@@ -1,1001 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- parse = require('../../lib/parsers/javascript'),
- remark = require('remark'),
- visit = require('unist-util-visit');
-
-function pick(obj, props) {
- if (Array.isArray(props)) {
- return props.reduce(function (memo, prop) {
- if (obj[prop] !== undefined) {
- memo[prop] = obj[prop];
- }
- return memo;
- }, {});
- }
- return obj[props];
-}
-
-function evaluate(fn, filename) {
- return parse({
- file: filename || 'test.js',
- source: fn instanceof Function ? '(' + fn.toString() + ')' : fn
- });
-}
-
-function addJSDocTag(tree) {
- visit(tree, 'link', function (node) {
- node.jsdoc = true;
- });
- return tree;
-}
-
-function removePosition(tree) {
- visit(tree, function (node) {
- delete node.position;
- });
- return tree;
-}
-
-test('parse - @abstract', function (t) {
- t.equal(evaluate(function () {
- /** @abstract */
- })[0].abstract, true);
-
- t.end();
-});
-
-test('parse - @access', function (t) {
- t.equal(evaluate(function () {
- /** @access public */
- })[0].access, 'public', 'access public');
-
- t.equal(evaluate(function () {
- /** @access protected */
- })[0].access, 'protected', 'access protected');
-
- t.equal(evaluate(function () {
- /** @access private */
- })[0].access, 'private', 'access private');
-
- t.end();
-});
-
-test('parse - @alias', function (t) {
- t.end();
-});
-
-test('parse - @arg', function (t) {
- t.end();
-});
-
-test('parse - @argument', function (t) {
- t.end();
-});
-
-test('parse - @augments', function (t) {
- t.equal(evaluate(function () {
- /** @augments Foo */
- })[0].augments[0].name, 'Foo', 'augments');
-
- t.end();
-});
-
-test('parse - @author', function (t) {
- t.end();
-});
-
-test('parse - @borrows', function (t) {
- t.end();
-});
-
-test('parse - @callback', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @callback name */
- })[0], ['kind', 'name', 'type']), {
- name: 'name',
- kind: 'typedef',
- type: {
- type: 'NameExpression',
- name: 'Function'
- }
- });
-
- t.end();
-});
-
-test('parse - @class', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @class */
- })[0], ['kind', 'name', 'type']), {
- kind: 'class'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @class name */
- })[0], ['kind', 'name', 'type']), {
- name: 'name',
- kind: 'class'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @class {Object} name */
- })[0], ['kind', 'name', 'type']), {
- name: 'name',
- kind: 'class',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.end();
-});
-
-test('parse - @classdesc', function (t) {
- t.deepEqual(evaluate(function () {
- /** @classdesc test */
- })[0].classdesc, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - @const', function (t) {
- t.end();
-});
-
-test('parse - @constant', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @constant */
- })[0], ['kind', 'name', 'type']), {
- kind: 'constant'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @constant name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'constant',
- name: 'name'
- });
-
-
- t.deepEqual(pick(evaluate(function () {
- /** @constant {Object} */
- })[0], ['kind', 'name', 'type']), {
- kind: 'constant',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @constant {Object} name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'constant',
- name: 'name',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.end();
-});
-
-test('parse - @constructor', function (t) {
- t.end();
-});
-
-test('parse - @constructs', function (t) {
- t.end();
-});
-
-test('parse - @copyright', function (t) {
- t.deepEqual(evaluate(function () {
- /** @copyright test */
- })[0].copyright, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - @default', function (t) {
- t.end();
-});
-
-test('parse - @defaultvalue', function (t) {
- t.end();
-});
-
-test('parse - @deprecated', function (t) {
- t.deepEqual(evaluate(function () {
- /** @deprecated test */
- })[0].deprecated, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - @desc', function (t) {
- t.deepEqual(evaluate(function () {
- /** @desc test */
- })[0].description, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - @description', function (t) {
- t.deepEqual(evaluate(function () {
- /** @description test */
- })[0].description, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - description', function (t) {
- t.deepEqual(evaluate(function () {
- /** test */
- })[0].description, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - @emits', function (t) {
- t.end();
-});
-
-test('parse - @enum', function (t) {
- t.end();
-});
-
-test('parse - @event', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @event name */
- })[0], ['kind', 'name']), {
- kind: 'event',
- name: 'name'
- });
-
- t.end();
-});
-
-test('parse - @example', function (t) {
- t.deepEqual(evaluate(function () {
- /** @example test */
- })[0].examples[0], {
- description: 'test'
- }, 'single line');
-
- t.deepEqual(evaluate(function () {
- /**
- * @example
- * a
- * b
- */
- })[0].examples[0], {
- description: 'a\nb'
- }, 'multiline');
-
- t.deepEqual(evaluate(function () {
- /**
- * @example caption
- * a
- * b
- */
- })[0].examples[0], {
- description: 'a\nb',
- caption: remark().parse('caption')
- }, 'with caption');
-
- t.deepEqual(evaluate(function () {
- /** @example */
- })[0].errors[0], {
- message: '@example without code',
- commentLineNumber: 0
- }, 'missing description');
-
- t.end();
-});
-
-test('parse - @exception', function (t) {
- t.end();
-});
-
-test('parse - @exports', function (t) {
- t.end();
-});
-
-test('parse - @extends', function (t) {
- t.deepEqual(evaluate(function () {
- /** @extends Foo */
- })[0].augments[0].name, 'Foo', 'extends');
-
- t.end();
-});
-
-test('parse - @external', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @external name */
- })[0], ['kind', 'name']), {
- kind: 'external',
- name: 'name'
- });
-
- t.end();
-});
-
-test('parse - @file', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @file */
- })[0], ['kind']), {
- kind: 'file'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @file desc */
- })[0], ['kind', 'description']), {
- kind: 'file',
- description: remark().parse('desc')
- });
-
- t.end();
-});
-
-test('parse - @fileoverview', function (t) {
- t.end();
-});
-
-test('parse - @fires', function (t) {
- t.end();
-});
-
-test('parse - @func', function (t) {
- t.end();
-});
-
-test('parse - @function', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @function */
- })[0], ['kind', 'name']), {
- kind: 'function'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @function name */
- })[0], ['kind', 'name']), {
- kind: 'function',
- name: 'name'
- });
-
- t.end();
-});
-
-test('parse - @global', function (t) {
- t.equal(evaluate(function () {
- /** @global */
- })[0].scope, 'global', 'global');
-
- t.end();
-});
-
-test('parse - @host', function (t) {
- t.end();
-});
-
-test('parse - @ignore', function (t) {
- t.equal(evaluate(function () {
- /** @ignore */
- })[0].ignore, true);
-
- t.end();
-});
-
-test('parse - @implements', function (t) {
- t.end();
-});
-
-test('parse - @inheritdoc', function (t) {
- t.end();
-});
-
-test('parse - @inner', function (t) {
- t.equal(evaluate(function () {
- /** @inner*/
- })[0].scope, 'inner', 'inner');
-
- t.end();
-});
-
-test('parse - @instance', function (t) {
- t.equal(evaluate(function () {
- /** @instance*/
- })[0].scope, 'instance', 'instance');
-
- t.end();
-});
-
-test('parse - @interface', function (t) {
- t.deepEqual(evaluate(function () {
- /** @interface */
- })[0].interface, true, 'anonymous');
-
- t.deepEqual(evaluate(function () {
- /** @interface Foo */
- })[0].name, 'Foo', 'named');
-
- t.end();
-});
-
-test('parse - @kind', function (t) {
- t.equal(evaluate(function () {
- /** @kind class */
- })[0].kind, 'class', 'kind');
-
- t.end();
-});
-
-test('parse - @lends', function (t) {
- t.equal(evaluate(function () {
- /** @lends lendee */
- })[0].lends, 'lendee', 'lends');
-
- t.end();
-});
-
-test('parse - @license', function (t) {
- t.end();
-});
-
-test('parse - @listens', function (t) {
- t.end();
-});
-
-test('parse - @member', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @member */
- })[0], ['kind', 'name', 'type']), {
- kind: 'member'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @member name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'member',
- name: 'name'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @member {Object} */
- })[0], ['kind', 'name', 'type']), {
- kind: 'member',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @member {Object} name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'member',
- name: 'name',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.end();
-});
-
-test('parse - @memberof', function (t) {
- t.equal(evaluate(function () {
- /** @memberof test */
- })[0].memberof, 'test', 'memberof');
-
- t.end();
-});
-
-test('parse - @method', function (t) {
- t.end();
-});
-
-test('parse - @mixes', function (t) {
- t.end();
-});
-
-test('parse - @mixin', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @mixin */
- })[0], ['kind', 'name']), {
- kind: 'mixin'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @mixin name */
- })[0], ['kind', 'name']), {
- kind: 'mixin',
- name: 'name'
- });
-
- t.end();
-});
-
-test('parse - @module', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @module */
- })[0], ['kind', 'name', 'type']), {
- kind: 'module'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @module name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'module',
- name: 'name'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @module {Object} name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'module',
- name: 'name',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.end();
-});
-
-test('parse - @name', function (t) {
- t.equal(evaluate(function () {
- /** @name test */
- })[0].name, 'test', 'name');
-
- t.end();
-});
-
-test('parse - @namespace', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @namespace */
- })[0], ['kind', 'name', 'type']), {
- kind: 'namespace'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @namespace name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'namespace',
- name: 'name'
- });
-
- t.deepEqual(pick(evaluate(function () {
- /** @namespace {Object} name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'namespace',
- name: 'name',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.end();
-});
-
-test('parse - @override', function (t) {
- t.equal(evaluate(function () {
- /** @override */
- })[0].override, true);
-
- t.end();
-});
-
-test('parse - @overview', function (t) {
- t.end();
-});
-
-test('parse - @param', function (t) {
- t.deepEqual(evaluate(function () {
- /** @param test */
- })[0].params[0], {
- name: 'test',
- lineNumber: 0
- }, 'name');
-
- t.deepEqual(evaluate(function () {
- /** @param {number} test */
- })[0].params[0], {
- name: 'test',
- type: {
- name: 'number',
- type: 'NameExpression'
- },
- lineNumber: 0
- }, 'name and type');
-
- t.deepEqual(evaluate(function () {
- /** @param {number} test - desc */
- })[0].params[0], {
- name: 'test',
- type: {
- name: 'number',
- type: 'NameExpression'
- },
- description: remark().parse('desc'),
- lineNumber: 0
- }, 'complete');
-
- t.end();
-});
-
-test('parse - @private', function (t) {
- t.equal(evaluate(function () {
- /** @private */
- })[0].access, 'private', 'private');
-
- t.end();
-});
-
-test('parse - @prop', function (t) {
- t.deepEqual(evaluate(function () {
- /** @prop {number} test */
- })[0].properties[0], {
- name: 'test',
- type: {
- name: 'number',
- type: 'NameExpression'
- },
- lineNumber: 0
- }, 'name and type');
-
- t.deepEqual(evaluate(function () {
- /** @prop {number} test - desc */
- })[0].properties[0], {
- name: 'test',
- type: {
- name: 'number',
- type: 'NameExpression'
- },
- description: remark().parse('desc'),
- lineNumber: 0
- }, 'complete');
-
- t.end();
-});
-
-test('parse - @property', function (t) {
- t.deepEqual(evaluate(function () {
- /** @property {number} test */
- })[0].properties[0], {
- name: 'test',
- type: {
- name: 'number',
- type: 'NameExpression'
- },
- lineNumber: 0
- }, 'name and type');
-
- t.deepEqual(evaluate(function () {
- /** @property {number} test - desc */
- })[0].properties[0], {
- name: 'test',
- type: {
- name: 'number',
- type: 'NameExpression'
- },
- description: remark().parse('desc'),
- lineNumber: 0
- }, 'complete');
-
- t.end();
-});
-
-test('parse - @protected', function (t) {
- t.equal(evaluate(function () {
- /** @protected */
- })[0].access, 'protected', 'protected');
-
- t.end();
-});
-
-test('parse - @public', function (t) {
- t.end();
-});
-
-test('parse - @readonly', function (t) {
- t.equal(evaluate(function () {
- /** @readonly */
- })[0].readonly, true);
-
- t.end();
-});
-
-test('parse - @requires', function (t) {
- t.end();
-});
-
-test('parse - @return', function (t) {
- t.deepEqual(evaluate(function () {
- /** @return test */
- })[0].returns[0], {
- description: remark().parse('test')
- }, 'description');
-
- t.deepEqual(evaluate(function () {
- /** @return {number} test */
- })[0].returns[0], {
- description: remark().parse('test'),
- type: {
- name: 'number',
- type: 'NameExpression'
- }
- }, 'description and type');
-
- t.end();
-});
-
-test('parse - @returns', function (t) {
- t.deepEqual(evaluate(function () {
- /** @returns test */
- })[0].returns[0], {
- description: remark().parse('test')
- }, 'description');
-
- t.deepEqual(evaluate(function () {
- /** @returns {number} test */
- })[0].returns[0], {
- description: remark().parse('test'),
- type: {
- name: 'number',
- type: 'NameExpression'
- }
- }, 'description and type');
-
- t.end();
-});
-
-test('parse - @see', function (t) {
- t.deepEqual(evaluate(function () {
- /** @see test */
- })[0].sees, [
- remark().parse('test')
- ], 'single');
-
- t.deepEqual(evaluate(function () {
- /**
- * @see a
- * @see b
- */
- })[0].sees, [
- remark().parse('a'),
- remark().parse('b')
- ], 'multiple');
-
- t.end();
-});
-
-test('parse - @since', function (t) {
- t.end();
-});
-
-test('parse - @static', function (t) {
- t.equal(evaluate(function () {
- /** @static */
- })[0].scope, 'static', 'static');
-
- t.end();
-});
-
-test('parse - @summary', function (t) {
- t.deepEqual(evaluate(function () {
- /** @summary test */
- })[0].summary, remark().parse('test'));
-
- t.end();
-});
-
-test('parse - @this', function (t) {
- t.end();
-});
-
-test('parse - @throws', function (t) {
- t.deepEqual(evaluate(function () {
- /** @throws desc */
- })[0].throws[0], {
- description: remark().parse('desc')
- }, 'description');
-
- t.deepEqual(evaluate(function () {
- /** @throws {Error} */
- })[0].throws[0], {
- type: {
- name: 'Error',
- type: 'NameExpression'
- }
- }, 'type');
-
- t.deepEqual(evaluate(function () {
- /** @throws {Error} desc */
- })[0].throws[0], {
- type: {
- name: 'Error',
- type: 'NameExpression'
- },
- description: remark().parse('desc')
- }, 'type and description');
-
- t.deepEqual(evaluate(function () {
- /**
- * @throws a
- * @throws b
- */
- })[0].throws, [{
- description: remark().parse('a')
- }, {
- description: remark().parse('b')
- }], 'multiple');
-
- t.end();
-});
-
-test('parse - @todo', function (t) {
- t.deepEqual(evaluate(function () {
- /** @todo test */
- })[0].todos, [
- remark().parse('test')
- ], 'single');
-
- t.deepEqual(evaluate(function () {
- /**
- * @todo a
- * @todo b
- */
- })[0].todos, [
- remark().parse('a'),
- remark().parse('b')
- ], 'multiple');
-
- t.end();
-});
-
-test('parse - @tutorial', function (t) {
- t.end();
-});
-
-test('parse - @type', function (t) {
- t.end();
-});
-
-test('parse - @typedef', function (t) {
- t.deepEqual(pick(evaluate(function () {
- /** @typedef {Object} name */
- })[0], ['kind', 'name', 'type']), {
- kind: 'typedef',
- name: 'name',
- type: {
- type: 'NameExpression',
- name: 'Object'
- }
- });
-
- t.end();
-});
-
-test('parse - @var', function (t) {
- t.end();
-});
-
-test('parse - @variation', function (t) {
- t.equal(evaluate(function () {
- /** @variation 1 */
- })[0].variation, 1, 'variation');
-
- t.end();
-});
-
-test('parse - @version', function (t) {
- t.end();
-});
-
-test('parse - @virtual', function (t) {
- t.end();
-});
-
-test('parse - unknown tag', function (t) {
- t.deepEqual(evaluate(function () {
- /** @unknown */
- })[0].errors[0], {
- message: 'unknown tag @unknown',
- commentLineNumber: 0
- });
-
- t.end();
-});
-
-test('parse - {@link}', function (t) {
- t.deepEqual(removePosition(evaluate(function () {
- /** {@link Foo} */
- })[0].description), addJSDocTag(removePosition(remark().parse('[Foo](Foo)'))));
-
- t.deepEqual(removePosition(evaluate(function () {
- /** {@link Foo|text} */
- })[0].description), addJSDocTag(removePosition(remark().parse('[text](Foo)'))));
-
- t.deepEqual(removePosition(evaluate(function () {
- /** {@link Foo text} */
- })[0].description), addJSDocTag(removePosition(remark().parse('[text](Foo)'))));
-
- t.done();
-});
-
-test('parse - {@linkcode}', function (t) {
- t.end();
-});
-
-test('parse - {@linkplain}', function (t) {
- t.end();
-});
-
-test('parse - {@tutorial}', function (t) {
- t.deepEqual(removePosition(evaluate(function () {
- /** {@tutorial id} */
- })[0].description), {
- type: 'root',
- children: [{
- type: 'paragraph',
- children: [{
- type: 'tutorial',
- url: 'id',
- jsdoc: true,
- title: null,
- children: [{
- type: 'text',
- value: 'id'
- }]
- }]
- }]
- });
-
- t.deepEqual(removePosition(evaluate(function () {
- /** {@tutorial id|text} */
- })[0].description), {
- type: 'root',
- children: [{
- type: 'paragraph',
- children: [{
- type: 'tutorial',
- url: 'id',
- jsdoc: true,
- title: null,
- children: [{
- type: 'text',
- value: 'text'
- }]
- }]
- }]
- });
-
- t.deepEqual(removePosition(evaluate(function () {
- /** {@tutorial id text} */
- })[0].description), {
- type: 'root',
- children: [{
- type: 'paragraph',
- children: [{
- type: 'tutorial',
- url: 'id',
- jsdoc: true,
- title: null,
- children: [{
- type: 'text',
- value: 'text'
- }]
- }]
- }]
- });
-
- t.done();
-});
diff --git a/test/lib/parsers/javascript.js b/test/lib/parsers/javascript.js
deleted file mode 100644
index 3c7e18499..000000000
--- a/test/lib/parsers/javascript.js
+++ /dev/null
@@ -1,66 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- remark = require('remark'),
- parse = require('../../../lib/parsers/javascript');
-
-function toComments(source, filename, opts) {
- source = typeof source === 'string' ? source : '(' + source.toString() + ')';
- return parse({
- file: filename || 'test.js',
- source: source
- }, opts);
-}
-
-test('parse - leading comment', function (t) {
- t.deepEqual(toComments(function () {
- /** one */
- /** two */
- function two() {}
- }).map(function (c) {
- return c.description;
- }), [remark().parse('one'), remark().parse('two')]);
- t.end();
-});
-
-test('parse - trailing comment', function (t) {
- t.deepEqual(toComments(function () {
- /** one */
- function one() {}
- /** two */
- }).map(function (c) {
- return c.description;
- }), [remark().parse('one'), remark().parse('two')]);
- t.end();
-});
-
-test('parse - unknown tag', function (t) {
- t.equal(toComments(function () {
- /** @unknown */
- })[0].tags[0].title, 'unknown');
- t.end();
-});
-
-test('parse - error', function (t) {
- t.deepEqual(toComments(function () {
- /** @param {foo */
- })[0].errors, [
- { message: 'Braces are not balanced' },
- { message: 'Missing or invalid tag name' }]);
- t.end();
-});
-
-test('parse - document exported', function (t) {
- t.equal(toComments(`
- export class C {}
- `).length, 0);
- t.equal(toComments(`
- export class C {}
- `, 'test.js', {documentExported: true}).length, 1);
- t.equal(toComments(`
- export class C {
- method() {}
- }
- `, 'test.js', {documentExported: true}).length, 2);
- t.end();
-});
diff --git a/test/lib/parsers/polyglot.js b/test/lib/parsers/polyglot.js
deleted file mode 100644
index 028abd122..000000000
--- a/test/lib/parsers/polyglot.js
+++ /dev/null
@@ -1,37 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- fs = require('fs'),
- path = require('path'),
- remark = require('remark'),
- polyglot = require('../../../lib/parsers/polyglot');
-
-test('polyglot', function (t) {
- var file = path.resolve(path.join(__dirname, '../../fixture/polyglot/blend.cpp'));
- var result = polyglot({
- file: file,
- source: fs.readFileSync(file, 'utf8')
- });
- delete result[0].context.file;
- delete result[0].context.sortKey;
- t.deepEqual(result, [{
- errors: [],
- context: {
- loc: { end: { column: 3, line: 40 }, start: { column: 1, line: 35 } } },
- description: remark().parse('This method moves a hex to a color'),
- loc: { end: { column: 3, line: 40 }, start: { column: 1, line: 35 } },
- name: 'hexToUInt32Color', params: [
- { lineNumber: 3, name: 'hex', type: { name: 'string', type: 'NameExpression' } } ],
- returns: [
- {
- description: remark().parse('color'),
- type: { name: 'number', type: 'NameExpression' } } ],
- tags: [ { description: null, lineNumber: 2, name: 'hexToUInt32Color', title: 'name' },
- { description: null, lineNumber: 3, name: 'hex', title: 'param', type: {
- name: 'string', type: 'NameExpression'
- } },
- { description: 'color', lineNumber: 4, title: 'returns', type: {
- name: 'number', type: 'NameExpression'
- } } ] } ], 'polyglot parser');
- t.end();
-});
diff --git a/test/lib/server.js b/test/lib/server.js
deleted file mode 100644
index 301510830..000000000
--- a/test/lib/server.js
+++ /dev/null
@@ -1,93 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- get = require('../utils').get,
- File = require('vinyl'),
- Server = require('../../lib/serve/server');
-
-var jsFile = new File({
- cwd: '/',
- base: '/test/',
- path: '/test/file.js',
- contents: new Buffer('var test = 123;')
-});
-
-var coffeeFile = new File({
- cwd: '/',
- base: '/test/',
- path: '/test/file.coffee',
- contents: new Buffer('test = 123')
-});
-
-var indexFile = new File({
- cwd: '/',
- base: '/test/',
- path: '/test/index.html',
- contents: new Buffer('')
-});
-
-test('server - throws on bad port', function (t) {
- t.throws(function () {
- var server = new Server('4001');
- }, 'port must be a number');
- t.throws(function () {
- var server = new Server();
- }, 'port must be provided');
- t.end();
-});
-
-test('server', function (t) {
- var server = new Server(4001);
- t.ok(server, 'server is initialized');
- server.start(function () {
-
- t.test('start can be called more than once, without a callback', function (tt) {
- server.start();
- tt.end();
- });
-
- t.test('base path', function (tt) {
- get('http://localhost:4001/file.coffee', function (code) {
- tt.equal(code, 404, 'does not have a file, emits 404');
- tt.end();
- });
- });
-
- t.test('base path', function (tt) {
- server.setFiles([coffeeFile]);
- get('http://localhost:4001/file.coffee', function (text) {
- tt.equal(text, 'test = 123', 'emits response');
- tt.end();
- });
- });
-
- t.test('reset files', function (tt) {
- server.setFiles([coffeeFile, jsFile]);
- get('http://localhost:4001/file.js', function (text) {
- tt.equal(text, 'var test = 123;', 'emits response');
- tt.end();
- });
- });
-
- t.test('index.html special case', function (tt) {
- server.setFiles([coffeeFile, indexFile, jsFile]);
- get('http://localhost:4001/', function (text) {
- tt.equal(text, '', 'sends index.html when / is requested');
- tt.end();
- });
- });
-
- t.test('cleanup', function (tt) {
- server.stop(function () {
- tt.end();
- });
- });
-
- t.test('stop can be called more than once, without a callback', function (tt) {
- server.stop();
- tt.end();
- });
-
- t.end();
- });
-});
diff --git a/test/lib/sort.js b/test/lib/sort.js
deleted file mode 100644
index 9b3f405aa..000000000
--- a/test/lib/sort.js
+++ /dev/null
@@ -1,280 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- sort = require('../../lib/sort'),
- path = require('path');
-
-test('sort stream alphanumeric', function (t) {
- var apples = { context: { sortKey: 'a' }, name: 'apples' };
- var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
- var banana = { context: { sortKey: 'c' }, name: 'bananas' };
-
- t.deepEqual(sort([
- apples, carrot, banana
- ]), [
- apples, carrot, banana
- ], 'sort stream alphanumeric');
-
- t.deepEqual(sort([
- carrot, apples, banana
- ]), [
- apples, carrot, banana
- ], 'sort stream alphanumeric');
-
- t.end();
-});
-
-test('sort stream with configuration', function (t) {
- var apples = { context: { sortKey: 'a' }, name: 'apples' };
- var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
- var bananas = { context: { sortKey: 'c' }, name: 'bananas' };
-
- t.deepEqual(sort([
- apples, carrot, bananas
- ], {
- toc: ['carrot', 'bananas']
- }), [
- carrot, bananas, apples
- ], 'with configuration');
-
- t.end();
-});
-
-test('sort stream with configuration and a section', function (t) {
- var apples = { context: { sortKey: 'a' }, name: 'apples' };
- var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
- var bananas = { context: { sortKey: 'c' }, name: 'bananas' };
-
- var section = { name: 'This is the banana type', description: 'here lies bananas' };
-
- var sectionMarkdown = {
- 'name': 'This is the banana type',
- 'description': {
- 'type': 'root',
- 'children': [{
- 'type': 'paragraph',
- 'children': [{
- 'type': 'text',
- 'value': 'here lies bananas',
- 'position': {
- 'start': {
- 'line': 1,
- 'column': 1,
- 'offset': 0
- },
- 'end': {
- 'line': 1,
- 'column': 18,
- 'offset': 17
- },
- 'indent': []
- }
- }],
- 'position': {
- 'start': {
- 'line': 1,
- 'column': 1,
- 'offset': 0
- },
- 'end': {
- 'line': 1,
- 'column': 18,
- 'offset': 17
- },'indent': []
- }
- }],
- 'position': {
- 'start': {
- 'line': 1,
- 'column': 1,
- 'offset': 0
- },
- 'end': {
- 'line': 1,
- 'column': 18,
- 'offset': 17
- }
- }
- },
- 'kind': 'note'
- };
-
- t.deepEqual(sort([
- apples, carrot, bananas
- ], {
- toc: ['carrot', section, 'bananas']
- }), [
- carrot, sectionMarkdown, bananas, apples
- ], 'with configuration');
-
- t.end();
-});
-
-test('sort an already-sorted stream containing a section/description', function (t) {
- // this happens in the 'serve' task
- var apples = { context: { sortKey: 'a' }, name: 'apples' };
- var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
- var bananas = { context: { sortKey: 'c' }, name: 'bananas' };
-
- var section = { name: 'This is the banana type', description: 'here lies bananas' };
- var sectionMarkdown = {
- 'name': 'This is the banana type',
- 'description': {
- 'type': 'root',
- 'children': [{
- 'type': 'paragraph',
- 'children': [{
- 'type': 'text',
- 'value': 'here lies bananas',
- 'position': {
- 'start': {
- 'line': 1,
- 'column': 1,
- 'offset': 0
- },
- 'end': {
- 'line': 1,
- 'column': 18,
- 'offset': 17
- },
- 'indent': []
- }
- }],
- 'position': {
- 'start': {
- 'line': 1,
- 'column': 1,
- 'offset': 0
- },
- 'end': {
- 'line': 1,
- 'column': 18,
- 'offset': 17
- },'indent': []
- }
- }],
- 'position': {
- 'start': {
- 'line': 1,
- 'column': 1,
- 'offset': 0
- },
- 'end': {
- 'line': 1,
- 'column': 18,
- 'offset': 17
- }
- }
- },
- 'kind': 'note'
- };
-
- var config = {
- toc: ['carrot', section, 'bananas']
- };
-
- var sortOnce = sort([apples, carrot, bananas], config);
- var sortTwice = sort(sortOnce, config);
- t.deepEqual(sortTwice, [carrot, sectionMarkdown, bananas, apples]);
- t.end();
-});
-
-test('sort toc with files', function (t) {
- var apples = { context: { sortKey: 'a' }, name: 'apples' };
- var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
- var bananas = { context: { sortKey: 'c' }, name: 'bananas' };
-
- var snowflake = {
- name: 'snowflake',
- file: 'test/fixture/snowflake.md'
- };
-
- var processedSnowflake = {
- name: 'snowflake',
- kind: 'note',
- description: {
- children: [{
- children: [{
- position: {
- end: {column: 16, line: 1, offset: 15},
- indent: [],
- start: {column: 3, line: 1, offset: 2}
- },
- type: 'text',
- value: 'The Snowflake'
- }],
- depth: 1,
- position: {
- end: {column: 16, line: 1, offset: 15},
- indent: [],
- start: {column: 1, line: 1, offset: 0}
- },
- type: 'heading'
- }],
- position: {
- end: {column: 1, line: 2, offset: 16},
- start: {column: 1, line: 1, offset: 0}
- },
- type: 'root'
- }
- };
- t.deepEqual(sort([
- apples, carrot, bananas
- ], {
- toc: [snowflake]
- }), [
- processedSnowflake, apples, carrot, bananas
- ], 'with configuration');
-
- t.end();
-});
-
-test('sort toc with files absolute path', function (t) {
- var apples = { context: { sortKey: 'a' }, name: 'apples' };
- var carrot = { context: { sortKey: 'b' }, name: 'carrot' };
- var bananas = { context: { sortKey: 'c' }, name: 'bananas' };
-
- var snowflake = {
- name: 'snowflake',
- file: path.join(__dirname, '../fixture/snowflake.md')
- };
-
- var processedSnowflake = {
- name: 'snowflake',
- kind: 'note',
- description: {
- children: [{
- children: [{
- position: {
- end: {column: 16, line: 1, offset: 15},
- indent: [],
- start: {column: 3, line: 1, offset: 2}
- },
- type: 'text',
- value: 'The Snowflake'
- }],
- depth: 1,
- position: {
- end: {column: 16, line: 1, offset: 15},
- indent: [],
- start: {column: 1, line: 1, offset: 0}
- },
- type: 'heading'
- }],
- position: {
- end: {column: 1, line: 2, offset: 16},
- start: {column: 1, line: 1, offset: 0}
- },
- type: 'root'
- }
- };
- t.deepEqual(sort([
- apples, carrot, bananas
- ], {
- toc: [snowflake]
- }), [
- processedSnowflake, apples, carrot, bananas
- ], 'with configuration');
-
- t.end();
-});
diff --git a/test/lib/walk.js b/test/lib/walk.js
deleted file mode 100644
index 1f20f7928..000000000
--- a/test/lib/walk.js
+++ /dev/null
@@ -1,74 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- walk = require('../../lib/walk');
-
-test('walk', function (group) {
-
- group.test('flat comments', function (t) {
-
- var comments = [{ name: 'Tom' }];
-
- function renamer(comment, options) {
- if (options) {
- comment.name = options.name;
- } else {
- comment.name = 'Tim';
- }
- }
-
- t.deepEqual(walk(comments, renamer), [
- { name: 'Tim' }
- ], 'no-option case');
-
- t.deepEqual(walk(comments, renamer, { name: 'John' }), [
- { name: 'John' }
- ], 'with options');
-
- t.end();
- });
-
- group.test('nested comments', function (t) {
-
- var comments = [{
- name: 'Tom',
- members: {
- static: [{
- name: 'Billy'
- }]
- }
- }];
-
- function renamer(comment, options) {
- if (options) {
- comment.name = options.name;
- } else {
- comment.name = 'Tim';
- }
- }
-
- t.deepEqual(walk(comments, renamer), [{
- name: 'Tim',
- members: {
- static: [{
- name: 'Tim'
- }]
- }
- }], 'no-option case');
-
- t.deepEqual(walk(comments, renamer, {
- name: 'Bob'
- }), [{
- name: 'Bob',
- members: {
- static: [{
- name: 'Bob'
- }]
- }
- }], 'with options');
-
- t.end();
- });
-
- group.end();
-});
diff --git a/test/linker.js b/test/linker.js
deleted file mode 100644
index f3cca7c7a..000000000
--- a/test/linker.js
+++ /dev/null
@@ -1,47 +0,0 @@
-var createLinkerStack = require('../lib/output/util/linker_stack'),
- test = require('tap').test;
-
-test('linkerStack', function (t) {
-
- var linkerStack = createLinkerStack({});
-
- t.equal(linkerStack.link('string'),
- 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String',
- 'Default global resolution of string');
-
- t.equal(createLinkerStack({
- paths: {
- Point: 'http://geojson.org/geojson-spec.html#point'
- }
- }).link('Point'),
- 'http://geojson.org/geojson-spec.html#point',
- 'Custom hardcoded path for a GeoJSON type');
-
-
- t.equal(createLinkerStack({
- paths: {
- Image: 'http://custom.com/'
- }
- }).link('Image'),
- 'http://custom.com/',
- 'Prefers config link to native.');
-
-
- var linker = createLinkerStack({
- paths: {
- Image: 'http://custom.com/'
- }
- });
-
- linker.namespaceResolver([{
- namespace: 'Image',
- }], function (namespace) {
- return '#' + namespace;
- });
-
- t.equal(linker.link('Image'),
- '#Image',
- 'Prefers local link over all.');
-
- t.end();
-});
diff --git a/test/normalize.js b/test/normalize.js
deleted file mode 100644
index e977f8d36..000000000
--- a/test/normalize.js
+++ /dev/null
@@ -1,17 +0,0 @@
-var walk = require('../lib/walk');
-
-module.exports = function (comments) {
- return walk(comments, function (comment) {
- var hasGithub = !!comment.context.github;
- var path = comment.context.path;
- comment.context = {
- loc: comment.context.loc
- };
- if (hasGithub) {
- comment.context.github = '[github]';
- }
- if (path) {
- comment.context.path = path;
- }
- });
-};
diff --git a/test/test.js b/test/test.js
deleted file mode 100644
index 91e561d0b..000000000
--- a/test/test.js
+++ /dev/null
@@ -1,297 +0,0 @@
-'use strict';
-
-var test = require('tap').test,
- documentationSchema = require('documentation-schema'),
- validate = require('json-schema'),
- documentation = require('../'),
- outputMarkdown = require('../lib/output/markdown.js'),
- outputMarkdownAST = require('../lib/output/markdown_ast.js'),
- outputHtml = require('../lib/output/html.js'),
- normalize = require('./normalize'),
- glob = require('glob'),
- path = require('path'),
- fs = require('fs'),
- _ = require('lodash'),
- chdir = require('chdir');
-
-var UPDATE = !!process.env.UPDATE;
-
-function makePOJO(ast) {
- return JSON.parse(JSON.stringify(ast));
-}
-
-function readOptionsFromFile(file) {
- var s = fs.readFileSync(file, 'utf-8');
- var lines = s.split(/\n/, 20);
- for (var i = 0; i < lines.length; i++) {
- var m = lines[i].match(/^\/\/\s+Options:\s*(.+)$/);
- if (m) {
- return JSON.parse(m[1]);
- }
- }
- return {};
-}
-
-if (fs.existsSync(path.join(__dirname, '../.git'))) {
- test('git option', function (t) {
- var file = path.join(__dirname, './fixture/simple.input.js');
- documentation.build([file], { github: true }, function (err, result) {
- t.ifError(err);
- normalize(result);
- var outputfile = file.replace('.input.js', '.output.github.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2));
- }
- var expect = require(outputfile);
- t.deepEqual(result, expect, 'produces correct JSON');
-
- outputMarkdown(result, {}, function (err, result) {
- t.ifError(err);
- var outputfile = file.replace('.input.js', '.output.github.md');
- if (UPDATE) {
- fs.writeFileSync(outputfile, result, 'utf8');
- }
- var expect = fs.readFileSync(outputfile, 'utf8');
- t.equal(result.toString(), expect, 'markdown output correct');
- t.end();
- });
- });
- });
-}
-
-test('external modules option', function (t) {
- documentation.build([
- path.join(__dirname, 'fixture', 'external.input.js')
- ], {
- external: '(external|external/node_modules/*)'
- }, function (err, result) {
- t.ifError(err);
- normalize(result);
- var outputfile = path.join(__dirname, 'fixture', '_external-deps-included.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2));
- }
- var expect = require(outputfile);
- t.deepEqual(result, expect);
- t.end();
- });
-});
-
-test('bad input', function (tt) {
- glob.sync(path.join(__dirname, 'fixture/bad', '*.input.js')).forEach(function (file) {
- tt.test(path.basename(file), function (t) {
- documentation.build([file], readOptionsFromFile(file), function (error, res) {
- t.equal(res, undefined);
- // make error a serializable object
- error = JSON.parse(JSON.stringify(error));
- // remove system-specific path
- delete error.filename;
- delete error.codeFrame;
- var outputfile = file.replace('.input.js', '.output.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(error, null, 2));
- }
- var expect = JSON.parse(fs.readFileSync(outputfile));
- t.deepEqual(error, expect);
- t.end();
- });
- });
- });
- tt.end();
-});
-
-test('html', function (tt) {
- glob.sync(path.join(__dirname, 'fixture/html', '*.input.js')).forEach(function (file) {
- tt.test(path.basename(file), function (t) {
- documentation.build([file], readOptionsFromFile(file), function (err, result) {
- t.ifError(err);
- outputHtml(result, null, function (err, result) {
- t.ifError(err);
- var clean = result.sort(function (a, b) {
- return a.path > b.path;
- }).filter(function (r) {
- return r.path.match(/(html)$/);
- }).map(function (r) {
- return r.contents;
- }).join('\n');
- var outputfile = file.replace('.input.js', '.output.files');
- if (UPDATE) {
- fs.writeFileSync(outputfile, clean, 'utf8');
- }
- var expect = fs.readFileSync(outputfile, 'utf8');
- t.deepEqual(clean, expect);
- t.end();
- });
- });
- });
- });
- tt.end();
-});
-
-test('outputs', function (ttt) {
- glob.sync(path.join(__dirname, 'fixture', '*.input.js')).forEach(function (file) {
- ttt.test(path.basename(file), function (tt) {
- documentation.build([file], readOptionsFromFile(file), function (err, result) {
- tt.ifError(err);
-
- tt.test('markdown', function (t) {
- outputMarkdown(_.cloneDeep(result), {}, function (err, result) {
- t.ifError(err);
- var outputfile = file.replace('.input.js', '.output.md');
- if (UPDATE) {
- fs.writeFileSync(outputfile, result, 'utf8');
- }
- var expect = fs.readFileSync(outputfile, 'utf8');
- t.equal(result.toString(), expect, 'markdown output correct');
- t.end();
- });
- });
-
- tt.test('markdown AST', function (t) {
- outputMarkdownAST(_.cloneDeep(result), {}, function (err, result) {
- t.ifError(err);
- var outputfile = file.replace('.input.js', '.output.md.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2), 'utf8');
- }
- var expect = JSON.parse(fs.readFileSync(outputfile, 'utf8'));
- t.deepEqual(result, expect, 'markdown AST output correct');
- t.end();
- });
- });
-
- tt.test('JSON', function (t) {
- normalize(result);
- result.forEach(function (comment) {
- validate(comment, documentationSchema.jsonSchema).errors.forEach(function (error) {
- t.ifError(error);
- });
- });
- var outputfile = file.replace('.input.js', '.output.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2));
- }
- var expect = require(outputfile);
- t.deepEqual(makePOJO(result), expect);
- t.end();
- });
-
- tt.end();
- });
- });
- });
- ttt.end();
-});
-
-test('outputs - sync', function (ttt) {
- glob.sync(path.join(__dirname, 'fixture/sync', '*.input.js')).forEach(function (file) {
- ttt.test(path.basename(file), function (tt) {
- var result = documentation.buildSync([file], readOptionsFromFile(file));
-
- tt.test('markdown', function (t) {
- outputMarkdown(result, {}, function (err, result) {
- t.ifError(err);
- var outputfile = file.replace('.input.js', '.output.md');
- if (UPDATE) {
- fs.writeFileSync(outputfile, result, 'utf8');
- }
- var expect = fs.readFileSync(outputfile, 'utf8');
- t.equal(result.toString(), expect, 'markdown output correct');
- t.end();
- });
- });
-
- tt.test('markdown AST', function (t) {
- outputMarkdownAST(result, {}, function (err, result) {
- t.ifError(err);
- var outputfile = file.replace('.input.js', '.output.md.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2), 'utf8');
- }
- var expect = JSON.parse(fs.readFileSync(outputfile, 'utf8'));
- t.deepEqual(result, expect, 'markdown AST output correct');
- t.end();
- });
- });
-
- tt.test('JSON', function (t) {
- normalize(result);
- var outputfile = file.replace('.input.js', '.output.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2));
- }
- var expect = require(outputfile);
- t.deepEqual(makePOJO(result), expect);
- t.end();
- });
-
- tt.end();
- });
- });
- ttt.end();
-});
-
-test('highlightAuto md output', function (t) {
- var file = path.join(__dirname, 'fixture/auto_lang_hljs/multilanguage.input.js'),
- hljsConfig = {hljs: {highlightAuto: true, languages: ['js', 'css', 'html']}};
-
- documentation.build(file, null, function (err, result) {
- t.ifError(err);
- outputMarkdown(result, hljsConfig, function (err, result) {
- t.ifError(err);
- var outputfile = file.replace('.input.js', '.output.md');
- if (UPDATE) {
- fs.writeFileSync(outputfile, result, 'utf8');
- }
- var expect = fs.readFileSync(outputfile, 'utf8');
- t.equal(result.toString(), expect, 'recognizes examples in html, css and js');
- t.end();
- });
- });
-});
-
-test('multi-file input', function (t) {
- documentation.build([
- path.join(__dirname, 'fixture', 'simple.input.js'),
- path.join(__dirname, 'fixture', 'simple-two.input.js')
- ], null, function (err, result) {
- t.ifError(err);
- normalize(result);
- var outputfile = path.join(__dirname, 'fixture', '_multi-file-input.json');
- if (UPDATE) {
- fs.writeFileSync(outputfile, JSON.stringify(result, null, 2));
- }
- var expect = require(outputfile);
- t.deepEqual(result, expect);
- t.end();
- });
-});
-
-test('accepts simple relative paths', function (t) {
- chdir(__dirname, function () {
- documentation.build('fixture/simple.input.js', null, function (err, data) {
- t.ifError(err);
- t.equal(data.length, 1, 'simple has no dependencies');
- t.end();
- });
- });
-});
-
-test('.lint', function (t) {
- chdir(__dirname, function () {
- documentation.lint('fixture/simple.input.js', null, function (err, data) {
- t.ifError(err);
- t.equal(data, '', 'outputs lint information');
- t.end();
- });
- });
-});
-
-test('.lint with bad input', function (t) {
- chdir(__dirname, function () {
- documentation.lint('fixture/bad/syntax.input.js', null, function (err, data) {
- t.ok(err, 'returns an error when syntax is incorrect');
- t.end();
- });
- });
-});
diff --git a/test/utils.js b/test/utils.js
deleted file mode 100644
index e9b075614..000000000
--- a/test/utils.js
+++ /dev/null
@@ -1,15 +0,0 @@
-var http = require('http'),
- concat = require('concat-stream');
-
-function get(url, callback) {
- http.get(url, function (res) {
- res.pipe(concat(function (text) {
- if (res.statusCode >= 400) {
- return callback(res.statusCode);
- }
- callback(text.toString());
- }));
- });
-}
-
-module.exports.get = get;
pFad - Phonifier reborn
Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.
Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.
Alternative Proxies:
Alternative Proxy
pFad Proxy
pFad v3 Proxy
pFad v4 Proxy
+